package com.sg.service.biz.dataassets.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.dataassets.req.*;
import com.sg.dto.biz.dataassets.req.*;
import com.sg.dto.biz.dataassets.res.*;
import com.sg.dto.integration.dataassets.DeleteResourceFileComReqDto;
import com.sg.dto.integration.framework.BatchQueryDeptComReqDto;
import com.sg.dto.integration.framework.BatchQueryDeptComRespDto;
import com.sg.dto.integration.framework.BatchQueryInductionRecordListComReqDto;
import com.sg.dto.integration.framework.BatchQueryInductionRecordListComRespDto;
import com.sg.service.base.dataassets.MOmsAlbumFileRelationService;
import com.sg.service.base.dataassets.MOmsAlbumService;
import com.sg.service.base.dataassets.MOmsAlbumShareRecService;
import com.sg.service.base.dataassets.MOmsResourceFileService;
import com.sg.service.biz.dataassets.ResourceFileService;
import com.sg.service.biz.dataassets.UnstructuredResourcesService;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.ResourceFileService;
import com.wicket.okrcomponent.integration.TemplateEngineService;
import com.wicket.okrcomponent.integration.dto.*;
import com.sg.common.exception.Assert;
import com.wicket.okrdataassets.common.exception.BizException;
import com.wicket.okrframework.integration.InductionRecordService;
import com.wicket.okrframework.integration.OrgService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class AlbumServiceImpl
        implements com.wicket.okrdataassets.biz.service.AlbumService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsAlbumService mOmsAlbumService;
    @Resource
    private MOmsAlbumFileRelationService mOmsAlbumFileRelationService;
    //@Resource
// private undefinedService undefinedService;
    @Resource
    private NbAlbum nbAlbum;
    @Resource
    private MOmsAlbumShareRecService mOmsAlbumShareRecService;
    @Resource
    private OrgService orgService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private UnstructuredResourcesService unstructuredResourcesService;
    @Resource
    private ResourceFileService resourceFileService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private MOmsResourceFileService mOmsResourceFileService;
    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;
    @Resource
    private ResourceFileService fwCompResourceFileClient;

    /**
     * D8批量删专辑下文件[10370]
     * gen by moon at 5/27/2025, 1:21:02 PM
     */
    @Trace(operationName = "D8批量删专辑下文件")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchDeleteFileOfAlbumRespDto batchDeleteFileOfAlbum(BatchDeleteFileOfAlbumReqDto reqDto) {


        //步骤0: M8执行非结构化数据接收入参字段入参 - implementUnstructuredDataReceiveField
        //ModelCode: receptionService
        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
        ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setResourceFileList(reqDto.getResourceFileList());//list-field-assign//sourceId:2047898_1
        }

        /*M8接收入参字段[10347]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


//步骤1: M8执行资源文件【循环开始】 - implementResourceFile
        //ModelCode: circulationCollections
        for (String circulationCollectionsRes : reqDto.getResourceFileList()) {


//步骤2: D8删除专辑下文件(公共) - deleteFileOfAlbumCom
            DeleteFileOfAlbumComRespDto deleteFileOfAlbumComRespDto = null;
            DeleteFileOfAlbumComReqDto deleteFileOfAlbumComReqDto = new DeleteFileOfAlbumComReqDto();
            if (circulationCollectionsRes != null) {
                deleteFileOfAlbumComReqDto.setResourceFileId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:2027547_1
            }

            /*D8删除专辑下文件(公共)[10359]   */
            Assert.isNull(deleteFileOfAlbumComReqDto.getResourceFileId(), "D8批量删专辑下文件-D8删除专辑下文件(公共)-资源文件ID不能为空", false);
            deleteFileOfAlbumComRespDto = deleteFileOfAlbumCom(deleteFileOfAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤3: M8执行【循环结束】 - implementLoopStopResource
            //ModelCode: circulationEnd
        }


        BatchDeleteFileOfAlbumRespDto retData = new BatchDeleteFileOfAlbumRespDto();


        return retData;
    }

    /**
     * D8新增专辑(公共)[10295]
     * gen by moon at 3/30/2025, 3:31:37 PM
     */
    @Trace(operationName = "D8新增专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddAlbumComRespDto addAlbumCom(AddAlbumComReqDto reqDto) {


        String string_1 = null;
//步骤0: 8-02-01新增专辑 - addAlbum
        String string = null;
        OmsAlbum omsAlbum = new OmsAlbum();
        if (reqDto != null) {
            omsAlbum.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2026337_1
            omsAlbum.setAlbumDescribe(reqDto.getAlbumDescribe());//SimpleFieldAssign//sourceId:2026338_1
            omsAlbum.setAlbumThumbnail(reqDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2026339_1
            omsAlbum.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2026340_1
            omsAlbum.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2026341_1
            omsAlbum.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026342_1
            omsAlbum.setAlbumShareFromId(reqDto.getAlbumShareFromId());//SimpleFieldAssign//sourceId:2026343_1
            omsAlbum.setIsShare(reqDto.getIsShare());//SimpleFieldAssign//sourceId:2026344_1
            omsAlbum.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2026345_1
            omsAlbum.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getAlbumName()));//FIRST_CHAR //todo 字段名称首字母来源为空,请设置!!;//sourceId:2026346_1
            omsAlbum.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:2026347_1
            omsAlbum.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2026348_1
        }

        /*8-02-01新增专辑[10294]   */
        Assert.isNull(omsAlbum.getAlbumName(), "D8新增专辑(公共)-8-02-01新增专辑-专辑名称不能为空", false);
        Assert.isNull(omsAlbum.getAlbumOwner(), "D8新增专辑(公共)-8-02-01新增专辑-版权归属类型不能为空", false);
        Assert.isNull(omsAlbum.getAlbumOwnerId(), "D8新增专辑(公共)-8-02-01新增专辑-版权归属对象ID不能为空", false);
        Assert.isNull(omsAlbum.getIsShare(), "D8新增专辑(公共)-8-02-01新增专辑-是否可分享不能为空", false);
        Assert.isNull(omsAlbum.getIsDefault(), "D8新增专辑(公共)-8-02-01新增专辑-是否默认专辑不能为空", false);
        Assert.isNull(omsAlbum.getFirstLetter(), "D8新增专辑(公共)-8-02-01新增专辑-名称首字母不能为空", false);
        Assert.isNull(omsAlbum.getSubjectLifeCycle(), "D8新增专辑(公共)-8-02-01新增专辑-主体生命周期不能为空", false);
        string = mOmsAlbumService.addAlbum(omsAlbum)/*vcase invoke 本地 method 方法调用;*/;


        string_1 = string;

        AddAlbumComRespDto retData = new AddAlbumComRespDto();
        if (string_1 != null) {
            retData.setAlbumId(string_1);//SimpleFieldAssign//sourceId:2026528_1
        }


        return retData;
    }

    /**
     * D8修改专辑(公共)[10322]
     * gen by moon at 3/30/2025, 3:31:43 PM
     */
    @Trace(operationName = "D8修改专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateAlbumComRespDto updateAlbumCom(UpdateAlbumComReqDto reqDto) {


        //步骤0: 8-02-01修改专辑 - updateAlbum
        boolean bOOLEAN;
        OmsAlbum omsAlbum = new OmsAlbum();
        if (reqDto != null) {
            omsAlbum.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2026529_1
            omsAlbum.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2026530_1
            omsAlbum.setAlbumDescribe(reqDto.getAlbumDescribe());//SimpleFieldAssign//sourceId:2026531_1
            omsAlbum.setAlbumThumbnail(reqDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2026532_1
            omsAlbum.setIsShare(reqDto.getIsShare());//SimpleFieldAssign//sourceId:2026533_1
            omsAlbum.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:2026534_1
            omsAlbum.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:2026535_1
            omsAlbum.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2026536_1
            omsAlbum.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2026537_1
            omsAlbum.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2026538_1
            omsAlbum.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2043928_1
        }

        /*8-02-01修改专辑[10297]   */
        Assert.isNull(omsAlbum.getAlbumId(), "D8修改专辑(公共)-8-02-01修改专辑-专辑ID不能为空", false);
        bOOLEAN = mOmsAlbumService.updateAlbum(omsAlbum)/*vcase invoke 本地 method 方法调用;*/;


        UpdateAlbumComRespDto retData = new UpdateAlbumComRespDto();


        return retData;
    }

    /**
     * D8新增专辑分享记录表[10323]
     * gen by moon at 11/19/2024, 8:22:55 PM
     */
    @Trace(operationName = "D8新增专辑分享记录表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddAlbumShareRecRespDto addAlbumShareRec(AddAlbumShareRecReqDto reqDto) {


        String string_1 = null;
//步骤0: 8-02-03新增专辑分享记录表 - addAlbumShareRec
        String string = null;
        OmsAlbumShareRec omsAlbumShareRec = new OmsAlbumShareRec();
        if (reqDto != null) {
            omsAlbumShareRec.setShareAlbumId(reqDto.getShareAlbumId());//SimpleFieldAssign//sourceId:2026560_1
            omsAlbumShareRec.setShareObjectTypeCode(reqDto.getShareObjectTypeCode());//SimpleFieldAssign//sourceId:2026566_1
            omsAlbumShareRec.setShareObjectId(reqDto.getShareObjectId());//SimpleFieldAssign//sourceId:2026781_1
            omsAlbumShareRec.setShareObjectOriginalRoleMemberId(reqDto.getShareObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026562_1
            omsAlbumShareRec.setSharerName(reqDto.getSharerName());//SimpleFieldAssign//sourceId:2028883_1
            omsAlbumShareRec.setReciveObjectTypeCode(reqDto.getReciveObjectTypeCode());//SimpleFieldAssign//sourceId:2026567_1
            omsAlbumShareRec.setReciveObjectId(reqDto.getReciveObjectId());//SimpleFieldAssign//sourceId:2026782_1
            omsAlbumShareRec.setReciveObjectOriginalRoleMemberId(reqDto.getReciveObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026564_1
            omsAlbumShareRec.setRecipientName(reqDto.getRecipientName());//SimpleFieldAssign//sourceId:2028884_1
        }

        /*8-02-03新增专辑分享记录表[10309]   */
        Assert.isNull(omsAlbumShareRec.getShareAlbumId(), "D8新增专辑分享记录表-8-02-03新增专辑分享记录表-分享的专辑ID不能为空", false);
        Assert.isNull(omsAlbumShareRec.getShareObjectTypeCode(), "D8新增专辑分享记录表-8-02-03新增专辑分享记录表-分享对象的类型编码不能为空", false);
        Assert.isNull(omsAlbumShareRec.getShareObjectId(), "D8新增专辑分享记录表-8-02-03新增专辑分享记录表-分享对象ID不能为空", false);
        Assert.isNull(omsAlbumShareRec.getReciveObjectTypeCode(), "D8新增专辑分享记录表-8-02-03新增专辑分享记录表-接收对象的类型编码不能为空", false);
        Assert.isNull(omsAlbumShareRec.getReciveObjectId(), "D8新增专辑分享记录表-8-02-03新增专辑分享记录表-接收对象ID不能为空", false);
        string = mOmsAlbumShareRecService.addAlbumShareRec(omsAlbumShareRec)/*vcase invoke 本地 method 方法调用;*/;


        string_1 = string;

        AddAlbumShareRecRespDto retData = new AddAlbumShareRecRespDto();
        if (string_1 != null) {
            retData.setAlbumShareRecId(string_1);//SimpleFieldAssign//sourceId:2026575_1
        }


        return retData;
    }

    /**
     * D8新增专辑文件关系(公共)[10324]
     * gen by moon at 11/21/2024, 9:38:02 PM
     */
    @Trace(operationName = "D8新增专辑文件关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddAlbumFileRelationComRespDto addAlbumFileRelationCom(AddAlbumFileRelationComReqDto reqDto) {


        String string_1 = null;
//virtualUsage D8查询资源文件详情(公共)  73543
        QueryResourceFileDetailComRespDto queryResourceFileDetailComRespDto = null;
        QueryResourceFileDetailComReqDto queryResourceFileDetailComReqDto = new QueryResourceFileDetailComReqDto();
        if (reqDto != null) {
            queryResourceFileDetailComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2028207_1_73543
        }

        /*D8查询资源文件详情(公共)[10321]   */
        Assert.isNull(queryResourceFileDetailComReqDto.getResourceFileId(), "D8新增专辑文件关系(公共)-D8查询资源文件详情(公共)-资源文件ID不能为空", false);
        queryResourceFileDetailComRespDto = resourceFileService.queryResourceFileDetailCom(queryResourceFileDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D8查专辑文件关系的文件别名是否重复  73534
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        if (queryResourceFileDetailComRespDto != null) {
            QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
            if (reqDto != null) {
                queryAlbumFileRelationListComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2028827_1_73534
            }
            if (queryResourceFileDetailComRespDto != null) {
                queryAlbumFileRelationListComReqDto.setResourceFileAlias(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2028352_1_73534
            }

            /*D8查专辑文件关系的文件别名是否重复[10330]   */
            Assert.isNull(queryAlbumFileRelationListComReqDto.getAlbumId(), "D8新增专辑文件关系(公共)-D8查专辑文件关系的文件别名是否重复-关联专辑ID不能为空", false);
            Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileAlias(), "D8新增专辑文件关系(公共)-D8查专辑文件关系的文件别名是否重复-资源文件别名不能为空", false);
            queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        }
        if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() > 0)) {
            //if(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 大于 0)  73535

            GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
            if (queryResourceFileDetailComRespDto != null) {
                GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto = new GenerateSemanticInstanceStoryComReqDto();
                generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("ALBUM_FILE_ALIAS_COPY");//CUSTOM_CONVENTION//sourceId:2028831_1_73536
                generateSemanticInstanceStoryComReqDto.setFirstFieldName("resourceFileName");//CUSTOM_CONVENTION//sourceId:2028832_1_73536
                if (queryResourceFileDetailComRespDto != null) {
                    generateSemanticInstanceStoryComReqDto.setFirstFieldValue(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2028833_1_73536
                }

                /*D2生成语义实例故事(公共)[8234]   */
                Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(), "D8新增专辑文件关系(公共)-D2生成语义实例故事(公共)-模板引擎标识不能为空", false);
                Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(), "D8新增专辑文件关系(公共)-D2生成语义实例故事(公共)-第一个字段字段名不能为空", false);
                Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(), "D8新增专辑文件关系(公共)-D2生成语义实例故事(公共)-第一个字段字段值不能为空", false);
                generateSemanticInstanceStoryComRespDto = fwCompTemplateEngineClient.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            String string = null;
            if (generateSemanticInstanceStoryComRespDto != null && queryResourceFileDetailComRespDto != null) {
                OmsAlbumFileRelation omsAlbumFileRelation = new OmsAlbumFileRelation();
                if (reqDto != null) {
                    omsAlbumFileRelation.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2026576_1_73558
                    omsAlbumFileRelation.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2026577_1_73558
                    omsAlbumFileRelation.setCopyrightOwnerName(reqDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2028870_1_73558
                    omsAlbumFileRelation.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028901_1_73558
                }
                if (generateSemanticInstanceStoryComRespDto != null) {
                    omsAlbumFileRelation.setResourceFileAlias(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2026578_1_73558
                }
                if (queryResourceFileDetailComRespDto != null) {
                    omsAlbumFileRelation.setResourceFileName(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2028392_1_73558
                    omsAlbumFileRelation.setResourceFileNumber(queryResourceFileDetailComRespDto.getResourceFileNumber());//SimpleFieldAssign//sourceId:2028393_1_73558
                    omsAlbumFileRelation.setResourceFileType(queryResourceFileDetailComRespDto.getResourceFileType());//SimpleFieldAssign//sourceId:2028394_1_73558
                    omsAlbumFileRelation.setResourceFileDetailType(queryResourceFileDetailComRespDto.getResourceFileDetailType());//SimpleFieldAssign//sourceId:2028395_1_73558
                    omsAlbumFileRelation.setResourceFileRelaPath(queryResourceFileDetailComRespDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2028396_1_73558
                    omsAlbumFileRelation.setResourceFileSize(queryResourceFileDetailComRespDto.getResourceFileSize());//SimpleFieldAssign//sourceId:2028397_1_73558
                    omsAlbumFileRelation.setResourceFileExtension(queryResourceFileDetailComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2028398_1_73558
                    omsAlbumFileRelation.setResourceCopyRightType(queryResourceFileDetailComRespDto.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2028399_1_73558
                    omsAlbumFileRelation.setResourceCopyRightHolderId(queryResourceFileDetailComRespDto.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2028400_1_73558
                    omsAlbumFileRelation.setCopyRightOriginalRoleMemberId(queryResourceFileDetailComRespDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2028401_1_73558
                }

                /*8-02-02新增专辑文件关系[10312]   */
                Assert.isNull(omsAlbumFileRelation.getResourceFileId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-资源文件ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getAlbumId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-关联专辑ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileAlias(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-资源文件别名不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileName(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件名称不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileNumber(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件编号不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileDetailType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件明细类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileRelaPath(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件相对路径不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileSize(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件大小不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceFileExtension(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件后缀不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceCopyRightType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件版权归属类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getResourceCopyRightHolderId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件版权归属对象ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation.getCreateOwnerObjectId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-创建于归属主体ID不能为空", false);
                string = mOmsAlbumFileRelationService.addAlbumFileRelation(omsAlbumFileRelation)/*vcase invoke 本地 method 方法调用;*/;


                string_1 = string;
            }
        } else {
            //else  73545

            String string_2 = null;
            if (queryResourceFileDetailComRespDto != null) {
                OmsAlbumFileRelation omsAlbumFileRelation_1 = new OmsAlbumFileRelation();
                if (reqDto != null) {
                    omsAlbumFileRelation_1.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2026576_1_73559
                    omsAlbumFileRelation_1.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2026577_1_73559
                    omsAlbumFileRelation_1.setCopyrightOwnerName(reqDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2028870_1_73559
                    omsAlbumFileRelation_1.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028901_1_73559
                }
                if (queryResourceFileDetailComRespDto != null) {
                    omsAlbumFileRelation_1.setResourceFileAlias(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2026578_1_73559
                    omsAlbumFileRelation_1.setResourceFileName(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2028392_1_73559
                    omsAlbumFileRelation_1.setResourceFileNumber(queryResourceFileDetailComRespDto.getResourceFileNumber());//SimpleFieldAssign//sourceId:2028393_1_73559
                    omsAlbumFileRelation_1.setResourceFileType(queryResourceFileDetailComRespDto.getResourceFileType());//SimpleFieldAssign//sourceId:2028394_1_73559
                    omsAlbumFileRelation_1.setResourceFileDetailType(queryResourceFileDetailComRespDto.getResourceFileDetailType());//SimpleFieldAssign//sourceId:2028395_1_73559
                    omsAlbumFileRelation_1.setResourceFileRelaPath(queryResourceFileDetailComRespDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2028396_1_73559
                    omsAlbumFileRelation_1.setResourceFileSize(queryResourceFileDetailComRespDto.getResourceFileSize());//SimpleFieldAssign//sourceId:2028397_1_73559
                    omsAlbumFileRelation_1.setResourceFileExtension(queryResourceFileDetailComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2028398_1_73559
                    omsAlbumFileRelation_1.setResourceCopyRightType(queryResourceFileDetailComRespDto.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2028399_1_73559
                    omsAlbumFileRelation_1.setResourceCopyRightHolderId(queryResourceFileDetailComRespDto.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2028400_1_73559
                    omsAlbumFileRelation_1.setCopyRightOriginalRoleMemberId(queryResourceFileDetailComRespDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2028401_1_73559
                }

                /*8-02-02新增专辑文件关系[10312]   */
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-资源文件ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getAlbumId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-关联专辑ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileAlias(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-资源文件别名不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileName(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件名称不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileNumber(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件编号不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileDetailType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件明细类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileRelaPath(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件相对路径不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileSize(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件大小不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceFileExtension(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件后缀不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceCopyRightType(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件版权归属类型不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getResourceCopyRightHolderId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-冗余资源文件版权归属对象ID不能为空", false);
                Assert.isNull(omsAlbumFileRelation_1.getCreateOwnerObjectId(), "D8新增专辑文件关系(公共)-8-02-02新增专辑文件关系-创建于归属主体ID不能为空", false);
                string_2 = mOmsAlbumFileRelationService.addAlbumFileRelation(omsAlbumFileRelation_1)/*vcase invoke 本地 method 方法调用;*/;


                string_1 = string_2;
            }
        }
        AddAlbumFileRelationComRespDto retData = new AddAlbumFileRelationComRespDto();
        if (string_1 != null) {
            retData.setAlbumRelationId(string_1);//SimpleFieldAssign//sourceId:2026583_1
        }


        return retData;
    }

    /**
     * D8修改专辑文件关系(公共)[10325]
     * gen by moon at 3/30/2025, 3:31:49 PM
     */
    @Trace(operationName = "D8修改专辑文件关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateAlbumFileRelationComRespDto updateAlbumFileRelationCom(UpdateAlbumFileRelationComReqDto reqDto) {


        //步骤0: 8-02-02修改专辑文件关系 - updateAlbumFileRelation
        boolean bOOLEAN;
        OmsAlbumFileRelation omsAlbumFileRelation = new OmsAlbumFileRelation();
        if (reqDto != null) {
            omsAlbumFileRelation.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2026586_1
            omsAlbumFileRelation.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2043989_1
            omsAlbumFileRelation.setResourceFileAlias(reqDto.getResourceFileAlias());//SimpleFieldAssign//sourceId:2026587_1
            omsAlbumFileRelation.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2026588_1
            omsAlbumFileRelation.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2026801_1
            omsAlbumFileRelation.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2026802_1
        }

        /*8-02-02修改专辑文件关系[10313]   */
        Assert.isNull(omsAlbumFileRelation.getAlbumRelationId(), "D8修改专辑文件关系(公共)-8-02-02修改专辑文件关系-专辑文档关系ID不能为空", false);
        bOOLEAN = mOmsAlbumFileRelationService.updateAlbumFileRelation(omsAlbumFileRelation)/*vcase invoke 本地 method 方法调用;*/;


        UpdateAlbumFileRelationComRespDto retData = new UpdateAlbumFileRelationComRespDto();


        return retData;
    }

    /**
     * D8删除专辑(公共)[10326]
     * gen by moon at 11/11/2024, 2:00:14 AM
     */
    @Trace(operationName = "D8删除专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteAlbumComRespDto deleteAlbumCom(DeleteAlbumComReqDto reqDto) {


        //步骤0: 8-02-01删除专辑 - deleteAlbum
        boolean bOOLEAN;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getAlbumId();
            ;//SimpleFieldAssign//sourceId:2026584_1
        }

        /*8-02-01删除专辑[10298]   */
        Assert.isNull(string, "D8删除专辑(公共)-8-02-01删除专辑-专辑ID不能为空", false);
        bOOLEAN = mOmsAlbumService.deleteAlbum(string)/*vcase invoke 本地 method 方法调用;*/;


        DeleteAlbumComRespDto retData = new DeleteAlbumComRespDto();


        return retData;
    }

    /**
     * D8查询专辑详情(公共)[10327]
     * gen by moon at 3/30/2025, 3:32:00 PM
     */
    @Trace(operationName = "D8查询专辑详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumDetailComRespDto queryAlbumDetailCom(QueryAlbumDetailComReqDto reqDto) {


        OmsAlbum omsAlbum_1 = null;
//步骤0: 8-02-01查询专辑详情 - queryAlbumDetail
        OmsAlbum omsAlbum = null;
        QueryAlbumDetailReq queryAlbumDetailReq = new QueryAlbumDetailReq();
        if (reqDto != null) {
            queryAlbumDetailReq.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2026592_1
            queryAlbumDetailReq.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2043943_1
            queryAlbumDetailReq.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2043944_1
            queryAlbumDetailReq.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2043945_1
            queryAlbumDetailReq.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2043946_1
        }

        /*8-02-01查询专辑详情[10299]   */

        omsAlbum = mOmsAlbumService.queryAlbumDetail(queryAlbumDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsAlbum_1 = omsAlbum;

        QueryAlbumDetailComRespDto retData = new QueryAlbumDetailComRespDto();
        if (omsAlbum_1 != null) {
            retData.setAlbumId(omsAlbum_1.getAlbumId());//SimpleFieldAssign//sourceId:2026606_1
            retData.setAlbumName(omsAlbum_1.getAlbumName());//SimpleFieldAssign//sourceId:2026607_1
            retData.setAlbumDescribe(omsAlbum_1.getAlbumDescribe());//SimpleFieldAssign//sourceId:2026608_1
            retData.setAlbumThumbnail(omsAlbum_1.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2026609_1
            retData.setAlbumOwner(omsAlbum_1.getAlbumOwner());//SimpleFieldAssign//sourceId:2026610_1
            retData.setAlbumOwnerId(omsAlbum_1.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2026611_1
            retData.setCopyRightOriginalRoleMemberId(omsAlbum_1.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026612_1
            retData.setIsShare(omsAlbum_1.getIsShare());//SimpleFieldAssign//sourceId:2026613_1
            retData.setSubjectLifeCycle(omsAlbum_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2026986_1
            retData.setCreateTime(omsAlbum_1.getCreateTime());//SimpleFieldAssign//sourceId:2026614_1
            retData.setOperateTime(omsAlbum_1.getOperateTime());//SimpleFieldAssign//sourceId:2026615_1
            retData.setIsValid(omsAlbum_1.getIsValid());//SimpleFieldAssign//sourceId:2026987_1
            retData.setIsDefault(omsAlbum_1.getIsDefault());//SimpleFieldAssign//sourceId:2043931_1
        }


        return retData;
    }

    /**
     * D8删除专辑文档关系(公共)[10328]
     * gen by moon at 11/11/2024, 2:00:18 AM
     */
    @Trace(operationName = "D8删除专辑文档关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteAlbumFileRelationComRespDto deleteAlbumFileRelationCom(DeleteAlbumFileRelationComReqDto reqDto) {


        //步骤0: 8-02-02删除专辑文件关系 - deleteAlbumFileRelation
        boolean bOOLEAN;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getAlbumRelationId();
            ;//SimpleFieldAssign//sourceId:2026604_1
        }

        /*8-02-02删除专辑文件关系[10314]   */
        Assert.isNull(string, "D8删除专辑文档关系(公共)-8-02-02删除专辑文件关系-专辑文档关系ID不能为空", false);
        bOOLEAN = mOmsAlbumFileRelationService.deleteAlbumFileRelation(string)/*vcase invoke 本地 method 方法调用;*/;


        DeleteAlbumFileRelationComRespDto retData = new DeleteAlbumFileRelationComRespDto();


        return retData;
    }

    /**
     * D8查询专辑列表(公共)[10329]
     * gen by moon at 4/1/2025, 10:56:02 PM
     */
    @Trace(operationName = "D8查询专辑列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumListComRespDto queryAlbumListCom(QueryAlbumListComReqDto reqDto) {


        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getQuerySortTypeCode() != null && reqDto.getQuerySortTypeCode().equals("CREATE_TIME_DESC"))) {
            //if(D8查询专辑列表(公共).查询排序类型 等于 按创建时间降序)  73445

            List<OmsAlbum> listOmsAlbum = new ArrayList<>();
            QueryAlbumListReq queryAlbumListReq = new QueryAlbumListReq();
            if (reqDto != null) {
                queryAlbumListReq.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2026616_1_73446
                queryAlbumListReq.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2026617_1_73446
                queryAlbumListReq.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2026618_1_73446
                queryAlbumListReq.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026619_1_73446
                queryAlbumListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2026621_1_73446
                queryAlbumListReq.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2043933_1_73446
            }

            /*8-02-01查询专辑列表（按创建时间降序）[10300]   */
            Assert.isNull(queryAlbumListReq.getAlbumOwner(), "D8查询专辑列表(公共)-8-02-01查询专辑列表（按创建时间降序）-版权归属类型不能为空", false);
            listOmsAlbum = mOmsAlbumService.queryAlbumList(queryAlbumListReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
            if (listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum) && listOmsAlbum.size() > 0) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum) && listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum)) {
                    receptionServiceReq.setAlbumList(listOmsAlbum.stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027059_1_73447
                }

                /*M8接收出参字段：专辑列表[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        }
        QueryAlbumListComRespDto retData = new QueryAlbumListComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setAlbumList(receptionServiceRes_1.getAlbumList().stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027061_1
        }


        return retData;
    }

    /**
     * D8查询专辑文件关系列表(公共)[10330]
     * gen by moon at 11/21/2024, 9:38:08 PM
     */
    @Trace(operationName = "D8查询专辑文件关系列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListCom(QueryAlbumFileRelationListComReqDto reqDto) {


        List<OmsAlbumFileRelation> listOmsAlbumFileRelation_1 = new ArrayList<>();
//步骤0: 8-02-02查询专辑文件关系列表 - queryAlbumFileRelationList
        List<OmsAlbumFileRelation> listOmsAlbumFileRelation = new ArrayList<>();
        QueryAlbumFileRelationListReq queryAlbumFileRelationListReq = new QueryAlbumFileRelationListReq();
        if (reqDto != null) {
            queryAlbumFileRelationListReq.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027400_1
            queryAlbumFileRelationListReq.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2026629_1
            queryAlbumFileRelationListReq.setResourceFileAlias(reqDto.getResourceFileAlias());//SimpleFieldAssign//sourceId:2026630_1
            queryAlbumFileRelationListReq.setResourceFileType(reqDto.getResourceFileType());//SimpleFieldAssign//sourceId:2026631_1
            queryAlbumFileRelationListReq.setResourceCopyRightType(reqDto.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2027215_1
            queryAlbumFileRelationListReq.setResourceCopyRightHolderId(reqDto.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2027216_1
            queryAlbumFileRelationListReq.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027217_1
            queryAlbumFileRelationListReq.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028898_1
            queryAlbumFileRelationListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2028472_1
            queryAlbumFileRelationListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2028473_1
            queryAlbumFileRelationListReq.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2027218_1
        }

        /*8-02-02查询专辑文件关系列表[10315]   */

        listOmsAlbumFileRelation = mOmsAlbumFileRelationService.queryAlbumFileRelationList(queryAlbumFileRelationListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsAlbumFileRelation_1 = listOmsAlbumFileRelation;

        QueryAlbumFileRelationListComRespDto retData = new QueryAlbumFileRelationListComRespDto();
        retData.setAlbumFileRelationList(listOmsAlbumFileRelation_1.stream().map(item -> BeanUtil.toBean(item, AlbumFileRelationDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2026914_1


        return retData;
    }

    /**
     * D8批量查询专辑(公共)[10331]
     * gen by moon at 4/1/2025, 10:56:00 PM
     */
    @Trace(operationName = "D8批量查询专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryAlbumComRespDto batchQueryAlbumCom(BatchQueryAlbumComReqDto reqDto) {


        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getQuerySortTypeCode() != null && reqDto.getQuerySortTypeCode().equals("CREATE_TIME_DESC"))) {
            //if(D8批量查询专辑(公共).查询排序类型 等于 按创建时间降序)  73448

            List<OmsAlbum> listOmsAlbum = new ArrayList<>();
            BatchQueryAlbumReq batchQueryAlbumReq = new BatchQueryAlbumReq();
            if (reqDto != null) {
                batchQueryAlbumReq.setAlbumList(reqDto.getAlbumList());//list-field-assign//sourceId:2026644_1_73449
            }

            /*8-02-01批量查询专辑列表[10302]   */

            listOmsAlbum = mOmsAlbumService.batchQueryAlbum(batchQueryAlbumReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
            if (listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum) && listOmsAlbum.size() > 0) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum) && listOmsAlbum != null && !CollectionUtil.isEmpty(listOmsAlbum)) {
                    receptionServiceReq.setAlbumList(listOmsAlbum.stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027078_1_73451
                }

                /*M8接收出参字段：专辑列表[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        }
        BatchQueryAlbumComRespDto retData = new BatchQueryAlbumComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setAlbumList(receptionServiceRes_1.getAlbumList().stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027080_1
        }


        return retData;
    }

    /**
     * D8查询专辑分享记录表列表(公共)[10332]
     * gen by moon at 11/16/2024, 3:33:16 PM
     */
    @Trace(operationName = "D8查询专辑分享记录表列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumShareRecListComRespDto queryAlbumShareRecListCom(QueryAlbumShareRecListComReqDto reqDto) {


        List<OmsAlbumShareRec> listOmsAlbumShareRec_1 = new ArrayList<>();
//步骤0: 8-02-03查询专辑分享记录表列表 - queryAlbumShareRecList
        List<OmsAlbumShareRec> listOmsAlbumShareRec = new ArrayList<>();
        QueryAlbumShareRecListReq queryAlbumShareRecListReq = new QueryAlbumShareRecListReq();
        if (reqDto != null) {
            queryAlbumShareRecListReq.setShareObjectTypeCode(reqDto.getShareObjectTypeCode());//SimpleFieldAssign//sourceId:2026652_1
            queryAlbumShareRecListReq.setShareObjectId(reqDto.getShareObjectId());//SimpleFieldAssign//sourceId:2026653_1
            queryAlbumShareRecListReq.setShareObjectOriginalRoleMemberId(reqDto.getShareObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026654_1
            queryAlbumShareRecListReq.setReciveObjectTypeCode(reqDto.getReciveObjectTypeCode());//SimpleFieldAssign//sourceId:2026655_1
            queryAlbumShareRecListReq.setReciveObjectId(reqDto.getReciveObjectId());//SimpleFieldAssign//sourceId:2026656_1
            queryAlbumShareRecListReq.setReciveObjectOriginalRoleMemberId(reqDto.getReciveObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026657_1
            queryAlbumShareRecListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2026658_1
        }

        /*8-02-03查询专辑分享记录表列表[10311]   */

        listOmsAlbumShareRec = mOmsAlbumShareRecService.queryAlbumShareRecList(queryAlbumShareRecListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsAlbumShareRec_1 = listOmsAlbumShareRec;

        QueryAlbumShareRecListComRespDto retData = new QueryAlbumShareRecListComRespDto();
        retData.setAlbumShareRecList(listOmsAlbumShareRec_1.stream().map(item -> BeanUtil.toBean(item, AlbumShareRecDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2026667_1


        return retData;
    }

    /**
     * D8修改专辑分享记录表[10333]
     * gen by moon at 11/11/2024, 2:00:30 AM
     */
    @Trace(operationName = "D8修改专辑分享记录表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateAlbumShareRecRespDto updateAlbumShareRec(UpdateAlbumShareRecReqDto reqDto) {


        //步骤0: 8-02-03修改专辑分享记录表 - updateAlbumShareRec
        boolean bOOLEAN;
        OmsAlbumShareRec omsAlbumShareRec = new OmsAlbumShareRec();
        if (reqDto != null) {
            omsAlbumShareRec.setAlbumShareRecId(reqDto.getAlbumShareRecId());//SimpleFieldAssign//sourceId:2026670_1
            omsAlbumShareRec.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2026671_1
            omsAlbumShareRec.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2026668_1
            omsAlbumShareRec.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2026669_1
        }

        /*8-02-03修改专辑分享记录表[10310]   */
        Assert.isNull(omsAlbumShareRec.getAlbumShareRecId(), "D8修改专辑分享记录表-8-02-03修改专辑分享记录表-专辑分享记录ID不能为空", false);
        bOOLEAN = mOmsAlbumShareRecService.updateAlbumShareRec(omsAlbumShareRec)/*vcase invoke 本地 method 方法调用;*/;


        UpdateAlbumShareRecRespDto retData = new UpdateAlbumShareRecRespDto();
        //todo dong 未找到匹配生成策略,请检查生成策略retData.setAlbumShareRecList(),数据源项; to( ==>tableName:undefined, fieldEnname:albumShareRecList ,uniqueId: 2026676_1 uniqueSourceId:out_null_null) from (varName:undefined fieldundefined)


        return retData;
    }

    /**
     * D8查询专辑文件关系详情(公共)[10342]
     * gen by moon at 5/26/2025, 9:36:04 PM
     */
    @Trace(operationName = "D8查询专辑文件关系详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailCom(QueryAlbumFileRelationDetailComReqDto reqDto) {


        OmsAlbumFileRelation omsAlbumFileRelation_1 = null;
//步骤0: 8-02-02查询专辑文件关系详情 - queryAlbumFileRelationDetail
        OmsAlbumFileRelation omsAlbumFileRelation = null;
        QueryAlbumFileRelationDetailReq queryAlbumFileRelationDetailReq = new QueryAlbumFileRelationDetailReq();
        if (reqDto != null) {
            queryAlbumFileRelationDetailReq.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2026845_1
            queryAlbumFileRelationDetailReq.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2043996_1
            queryAlbumFileRelationDetailReq.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2043997_1
            queryAlbumFileRelationDetailReq.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047439_1
            queryAlbumFileRelationDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2047440_1
            queryAlbumFileRelationDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2047441_1
            queryAlbumFileRelationDetailReq.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2047442_1
        }

        /*8-02-02查询专辑文件关系详情[10341]   */

        omsAlbumFileRelation = mOmsAlbumFileRelationService.queryAlbumFileRelationDetail(queryAlbumFileRelationDetailReq)/*vcase invoke 本地 method 方法调用;*/;

        omsAlbumFileRelation.setResourceFileRelaPath(CommonFunctionHelper.getFilePath(omsAlbumFileRelation.getResourceFileRelaPath()));//otherModel: ALL_PATH
        omsAlbumFileRelation_1 = omsAlbumFileRelation;

        QueryAlbumFileRelationDetailComRespDto retData = new QueryAlbumFileRelationDetailComRespDto();
        if (omsAlbumFileRelation_1 != null) {
            retData.setAlbumRelationId(omsAlbumFileRelation_1.getAlbumRelationId());//SimpleFieldAssign//sourceId:2026860_1
            retData.setResourceFileId(omsAlbumFileRelation_1.getResourceFileId());//SimpleFieldAssign//sourceId:2026861_1
            retData.setAlbumId(omsAlbumFileRelation_1.getAlbumId());//SimpleFieldAssign//sourceId:2047465_1
            retData.setResourceFileAlias(omsAlbumFileRelation_1.getResourceFileAlias());//SimpleFieldAssign//sourceId:2026862_1
            retData.setResourceFileName(omsAlbumFileRelation_1.getResourceFileName());//SimpleFieldAssign//sourceId:2026863_1
            retData.setResourceFileNumber(omsAlbumFileRelation_1.getResourceFileNumber());//SimpleFieldAssign//sourceId:2026864_1
            retData.setResourceFileRelaPath(omsAlbumFileRelation_1.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2026865_1
            retData.setResourceFileExtension(omsAlbumFileRelation_1.getResourceFileExtension());//SimpleFieldAssign//sourceId:2026866_1
            retData.setResourceCopyRightType(omsAlbumFileRelation_1.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2026867_1
            retData.setResourceCopyRightHolderId(omsAlbumFileRelation_1.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2026868_1
            retData.setCopyRightOriginalRoleMemberId(omsAlbumFileRelation_1.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2026869_1
            retData.setCopyrightOwnerName(omsAlbumFileRelation_1.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2028877_1
            retData.setSubjectLifeCycle(omsAlbumFileRelation_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2027393_1
            retData.setCreateOwnerObjectId(omsAlbumFileRelation_1.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2044062_1
            retData.setCreateTime(omsAlbumFileRelation_1.getCreateTime());//SimpleFieldAssign//sourceId:2026870_1
            retData.setReleaseTime(omsAlbumFileRelation_1.getReleaseTime());//SimpleFieldAssign//sourceId:2026871_1
            retData.setOperateTime(omsAlbumFileRelation_1.getOperateTime());//SimpleFieldAssign//sourceId:2026872_1
            retData.setIsValid(omsAlbumFileRelation_1.getIsValid());//SimpleFieldAssign//sourceId:2027394_1
        }


        return retData;
    }

    /**
     * D8查询分享的专辑列表(公共)[10350]
     * gen by moon at 3/30/2025, 3:32:11 PM
     */
    @Trace(operationName = "D8查询分享的专辑列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuerySharedAlbumListComRespDto querySharedAlbumListCom(QuerySharedAlbumListComReqDto reqDto) {


        QueryAlbumShareRecListComRespDto queryAlbumShareRecListComRespDto_1 = null;
        BatchQueryAlbumComRespDto batchQueryAlbumComRespDto_1 = null;
//virtualUsage D8查询专辑分享记录表列表(公共)  73442
        QueryAlbumShareRecListComRespDto queryAlbumShareRecListComRespDto = null;
        QueryAlbumShareRecListComReqDto queryAlbumShareRecListComReqDto = new QueryAlbumShareRecListComReqDto();
        if (reqDto != null) {
            queryAlbumShareRecListComReqDto.setShareObjectTypeCode(reqDto.getShareObjectTypeCode());//SimpleFieldAssign//sourceId:2027003_1_73442
            queryAlbumShareRecListComReqDto.setShareObjectId(reqDto.getShareObjectId());//SimpleFieldAssign//sourceId:2027004_1_73442
            queryAlbumShareRecListComReqDto.setShareObjectOriginalRoleMemberId(reqDto.getShareObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027005_1_73442
            queryAlbumShareRecListComReqDto.setReciveObjectTypeCode(reqDto.getReciveObjectTypeCode());//SimpleFieldAssign//sourceId:2027006_1_73442
            queryAlbumShareRecListComReqDto.setReciveObjectId(reqDto.getReciveObjectId());//SimpleFieldAssign//sourceId:2027007_1_73442
            queryAlbumShareRecListComReqDto.setReciveObjectOriginalRoleMemberId(reqDto.getReciveObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027008_1_73442
            queryAlbumShareRecListComReqDto.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2027009_1_73442
        }

        /*D8查询专辑分享记录表列表(公共)[10332]   */

        queryAlbumShareRecListComRespDto = queryAlbumShareRecListCom(queryAlbumShareRecListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryAlbumShareRecListComRespDto_1 = queryAlbumShareRecListComRespDto;
        if ((queryAlbumShareRecListComRespDto != null && queryAlbumShareRecListComRespDto.getAlbumShareRecList() != null && queryAlbumShareRecListComRespDto.getAlbumShareRecList().size() > 0)) {
            //if(D8查询专辑分享记录表列表(公共).专辑分享记录表列表数据集条数 大于 0)  73443

            BatchQueryAlbumComRespDto batchQueryAlbumComRespDto = null;
            if (queryAlbumShareRecListComRespDto != null) {
                BatchQueryAlbumComReqDto batchQueryAlbumComReqDto = new BatchQueryAlbumComReqDto();
                if (reqDto != null) {
                    batchQueryAlbumComReqDto.setQuerySortTypeCode(reqDto.getQuerySortTypeCode());//SimpleFieldAssign//sourceId:2027114_1_73444
                }
                if (queryAlbumShareRecListComRespDto != null && queryAlbumShareRecListComRespDto.getAlbumShareRecList() != null && !CollectionUtil.isEmpty(queryAlbumShareRecListComRespDto.getAlbumShareRecList())) {
                    batchQueryAlbumComReqDto.setAlbumList(queryAlbumShareRecListComRespDto.getAlbumShareRecList().stream().map(item -> item.getShareAlbumId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2027011_1_73444
                }

                /*D8批量查询专辑(公共)[10331]   */
                Assert.isNull(batchQueryAlbumComReqDto.getQuerySortTypeCode(), "D8查询分享的专辑列表(公共)-D8批量查询专辑(公共)-查询排序类型不能为空", false);
                batchQueryAlbumComRespDto = batchQueryAlbumCom(batchQueryAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


                batchQueryAlbumComRespDto_1 = batchQueryAlbumComRespDto;
            }
        }
        QuerySharedAlbumListComRespDto retData = new QuerySharedAlbumListComRespDto();
        //数据集融合  MoreListToOneSource
        if (queryAlbumShareRecListComRespDto_1 != null && !CollectionUtil.isEmpty(queryAlbumShareRecListComRespDto_1.getAlbumShareRecList())) {
            for (AlbumShareRecDto albumShareRecDto : queryAlbumShareRecListComRespDto_1.getAlbumShareRecList()) {
                AlbumShareRecDto retElm = new AlbumShareRecDto();
                if (queryAlbumShareRecListComRespDto_1 != null) {
                    retElm.setAlbumShareRecId(albumShareRecDto.getAlbumShareRecId());//SimpleFieldAssign//sourceId:428127_2
                    retElm.setShareAlbumId(albumShareRecDto.getShareAlbumId());//SimpleFieldAssign//sourceId:427942_2
                    retElm.setShareObjectTypeCode(albumShareRecDto.getShareObjectTypeCode());//SimpleFieldAssign//sourceId:427968_2
                    retElm.setShareObjectId(albumShareRecDto.getShareObjectId());//SimpleFieldAssign//sourceId:427969_2
                    retElm.setShareObjectOriginalRoleMemberId(albumShareRecDto.getShareObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427970_2
                    retElm.setSharerName(albumShareRecDto.getSharerName());//SimpleFieldAssign//sourceId:428101_2
                    retElm.setReciveObjectTypeCode(albumShareRecDto.getReciveObjectTypeCode());//SimpleFieldAssign//sourceId:427944_2
                    retElm.setReciveObjectId(albumShareRecDto.getReciveObjectId());//SimpleFieldAssign//sourceId:427946_2
                    retElm.setReciveObjectOriginalRoleMemberId(albumShareRecDto.getReciveObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427947_2
                    retElm.setRecipientName(albumShareRecDto.getRecipientName());//SimpleFieldAssign//sourceId:428102_2
                }
                retData.getAlbumShareRecList().add(retElm);
                if (batchQueryAlbumComRespDto_1 != null) {
                    for (AlbumDto albumDto : batchQueryAlbumComRespDto_1.getAlbumList()) {
                        if (albumDto.getAlbumId().equals(albumShareRecDto.getShareAlbumId())) {
                            if (batchQueryAlbumComRespDto_1 != null) {
                                retElm.setAlbumName(albumDto.getAlbumName());//SimpleFieldAssign//sourceId:427943_2
                                retElm.setAlbumThumbnail(albumDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:427945_2
                                retElm.setIsDefault(albumDto.getIsDefault());//SimpleFieldAssign//sourceId:433451_2
                                retElm.setCreateTime(albumDto.getCreateTime());//SimpleFieldAssign//sourceId:427948_2
                            }
                        }
                    }
                }

            }
        }//sourceId:2028456_1


        return retData;
    }

    /**
     * D8查询个人或部门的专辑列表[10351]
     * gen by moon at 4/3/2025, 12:00:28 AM
     */
    @Trace(operationName = "D8查询个人或部门的专辑列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonOrDeptAlbumListRespDto queryPersonOrDeptAlbumList(QueryPersonOrDeptAlbumListReqDto reqDto) {


        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getAlbumQueryTypeCode() != null && reqDto.getAlbumQueryTypeCode().equals("BY_AFFILIATION"))) {
            //if(D8查询个人或部门的专辑列表.专辑查询类型 等于 按归属查专辑)  73452

            InitDefaultAlbumComRespDto initDefaultAlbumComRespDto = null;
            InitDefaultAlbumComReqDto initDefaultAlbumComReqDto = new InitDefaultAlbumComReqDto();
            if (reqDto != null) {
                initDefaultAlbumComReqDto.setAlbumOwner(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:2044111_1_73992
                initDefaultAlbumComReqDto.setAlbumOwnerId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2044112_1_73992
                initDefaultAlbumComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2044113_1_73992
            }

            /*D8初始化默认专辑(公共)[10512]   */
            Assert.isNull(initDefaultAlbumComReqDto.getAlbumOwner(), "D8查询个人或部门的专辑列表-D8初始化默认专辑(公共)-版权归属类型不能为空", false);
            initDefaultAlbumComRespDto = initDefaultAlbumCom(initDefaultAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


            QueryAlbumListComRespDto queryAlbumListComRespDto = null;
            QueryAlbumListComReqDto queryAlbumListComReqDto = new QueryAlbumListComReqDto();
            if (reqDto != null) {
                queryAlbumListComReqDto.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2027023_1_73453
                queryAlbumListComReqDto.setAlbumOwner(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:2027024_1_73453
                queryAlbumListComReqDto.setAlbumOwnerId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2027025_1_73453
                queryAlbumListComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027026_1_73453
                queryAlbumListComReqDto.setQuerySortTypeCode(reqDto.getQuerySortTypeCode());//SimpleFieldAssign//sourceId:2027113_1_73453
                queryAlbumListComReqDto.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2027028_1_73453
                queryAlbumListComReqDto.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2043935_1_73453
            }

            /*D8查询专辑列表(公共)[10329]   */
            Assert.isNull(queryAlbumListComReqDto.getAlbumOwner(), "D8查询个人或部门的专辑列表-D8查询专辑列表(公共)-版权归属类型不能为空", false);
            Assert.isNull(queryAlbumListComReqDto.getQuerySortTypeCode(), "D8查询个人或部门的专辑列表-D8查询专辑列表(公共)-查询排序类型不能为空", false);
            queryAlbumListComRespDto = queryAlbumListCom(queryAlbumListComReqDto)/*vcase invoke 同服务,同domain*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
            if (queryAlbumListComRespDto != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (queryAlbumListComRespDto != null && queryAlbumListComRespDto.getAlbumList() != null && !CollectionUtil.isEmpty(queryAlbumListComRespDto.getAlbumList())) {
                    receptionServiceReq.setAlbumList(//objList-to-objLists
                            queryAlbumListComRespDto.getAlbumList().stream().map(item -> {
                                AlbumDto elm = new AlbumDto();
                                //todo dong 未找到匹配生成策略,请检查生成策略elm.setAlbumShareRecId(),数据源项; to( elm==>tableName:oms_album_share_rec, fieldEnname:albumShareRecId ,uniqueId: 428131_2_73458 uniqueSourceId:null_null) from (varName:undefined fieldundefined)
                                //todo dong 未找到匹配生成策略,请检查生成策略elm.setSharerName(),数据源项; to( elm==>tableName:oms_album_share_rec, fieldEnname:sharerName ,uniqueId: 428117_2_73458 uniqueSourceId:null_null) from (varName:undefined fieldundefined)
//todo dong 未找到匹配生成策略,请检查生成策略elm.setRecipientName(),数据源项; to( elm==>tableName:oms_album_share_rec, fieldEnname:recipientName ,uniqueId: 428118_2_73458 uniqueSourceId:null_null) from (varName:undefined fieldundefined)
                                if (item != null) {
                                    elm.setAlbumId(item.getAlbumId());//SimpleFieldAssign//sourceId:427332_2_73458
                                    elm.setAlbumName(item.getAlbumName());//SimpleFieldAssign//sourceId:427333_2_73458
                                    elm.setAlbumThumbnail(item.getAlbumThumbnail());//SimpleFieldAssign//sourceId:427334_2_73458
                                    elm.setAlbumOwner(item.getAlbumOwner());//SimpleFieldAssign//sourceId:427335_2_73458
                                    elm.setAlbumOwnerId(item.getAlbumOwnerId());//SimpleFieldAssign//sourceId:427336_2_73458
                                    elm.setCopyRightOriginalRoleMemberId(item.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427337_2_73458
                                    elm.setIsDefault(item.getIsDefault());//SimpleFieldAssign//sourceId:433453_2_73458
                                    elm.setCreateTime(item.getCreateTime());//SimpleFieldAssign//sourceId:427338_2_73458
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027109_1_73458
                }

                /*M8接收出参字段：专辑列表[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getAlbumQueryTypeCode() != null && reqDto.getAlbumQueryTypeCode().equals("BY_SHARE"))) {
            //elseif(D8查询个人或部门的专辑列表.专辑查询类型 等于 按分享查询专辑)  73454

            QuerySharedAlbumListComRespDto querySharedAlbumListComRespDto = null;
            QuerySharedAlbumListComReqDto querySharedAlbumListComReqDto = new QuerySharedAlbumListComReqDto();
            if (reqDto != null) {
                querySharedAlbumListComReqDto.setShareObjectTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:2027030_1_73456
                querySharedAlbumListComReqDto.setShareObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2027031_1_73456
                querySharedAlbumListComReqDto.setShareObjectOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027032_1_73456
                querySharedAlbumListComReqDto.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2027036_1_73456
                querySharedAlbumListComReqDto.setQuerySortTypeCode(reqDto.getQuerySortTypeCode());//SimpleFieldAssign//sourceId:2027116_1_73456
            }

            /*D8查询分享的专辑列表(公共)[10350]   */
            Assert.isNull(querySharedAlbumListComReqDto.getQuerySortTypeCode(), "D8查询个人或部门的专辑列表-D8查询分享的专辑列表(公共)-查询排序类型不能为空", false);
            querySharedAlbumListComRespDto = querySharedAlbumListCom(querySharedAlbumListComReqDto)/*vcase invoke 同服务,同domain*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_2 = null;
            if (querySharedAlbumListComRespDto != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq_1 = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (querySharedAlbumListComRespDto != null && querySharedAlbumListComRespDto.getAlbumShareRecList() != null && !CollectionUtil.isEmpty(querySharedAlbumListComRespDto.getAlbumShareRecList())) {
                    receptionServiceReq_1.setAlbumList(//objList-to-objLists
                            querySharedAlbumListComRespDto.getAlbumShareRecList().stream().map(item -> {
                                AlbumDto elm = new AlbumDto();
                                if (item != null) {
                                    elm.setAlbumShareRecId(item.getAlbumShareRecId());//SimpleFieldAssign//sourceId:428131_2_73459
                                    elm.setAlbumId(item.getShareAlbumId());//SimpleFieldAssign//sourceId:427332_2_73459
                                    elm.setAlbumName(item.getAlbumName());//SimpleFieldAssign//sourceId:427333_2_73459
                                    elm.setAlbumThumbnail(item.getAlbumThumbnail());//SimpleFieldAssign//sourceId:427334_2_73459
                                    elm.setAlbumOwner(item.getReciveObjectTypeCode());//SimpleFieldAssign//sourceId:427335_2_73459
                                    elm.setAlbumOwnerId(item.getReciveObjectId());//SimpleFieldAssign//sourceId:427336_2_73459
                                    elm.setCopyRightOriginalRoleMemberId(item.getReciveObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427337_2_73459
                                    elm.setSharerName(item.getSharerName());//SimpleFieldAssign//sourceId:428117_2_73459
                                    elm.setRecipientName(item.getRecipientName());//SimpleFieldAssign//sourceId:428118_2_73459
                                    elm.setIsDefault(item.getIsDefault());//SimpleFieldAssign//sourceId:433453_2_73459
                                    elm.setCreateTime(item.getCreateTime());//SimpleFieldAssign//sourceId:427338_2_73459
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027109_1_73459
                }

                /*M8接收出参字段：专辑列表[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes_2 = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getAlbumQueryTypeCode() != null && reqDto.getAlbumQueryTypeCode().equals("BY_RECEIVED"))) {
            //elseif(D8查询个人或部门的专辑列表.专辑查询类型 等于 按接收分享查询专辑)  73455

            QuerySharedAlbumListComRespDto querySharedAlbumListComRespDto_2 = null;
            QuerySharedAlbumListComReqDto querySharedAlbumListComReqDto_1 = new QuerySharedAlbumListComReqDto();
            if (reqDto != null) {
                querySharedAlbumListComReqDto_1.setReciveObjectTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:2027033_1_73457
                querySharedAlbumListComReqDto_1.setReciveObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2027034_1_73457
                querySharedAlbumListComReqDto_1.setReciveObjectOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027035_1_73457
                querySharedAlbumListComReqDto_1.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2027036_1_73457
                querySharedAlbumListComReqDto_1.setQuerySortTypeCode(reqDto.getQuerySortTypeCode());//SimpleFieldAssign//sourceId:2027116_1_73457
            }

            /*D8查询分享的专辑列表(公共)[10350]   */
            Assert.isNull(querySharedAlbumListComReqDto_1.getQuerySortTypeCode(), "D8查询个人或部门的专辑列表-D8查询分享的专辑列表(公共)-查询排序类型不能为空", false);
            querySharedAlbumListComRespDto_2 = querySharedAlbumListCom(querySharedAlbumListComReqDto_1)/*vcase invoke 同服务,同domain*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_3 = null;
            if (querySharedAlbumListComRespDto_2 != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq_2 = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (querySharedAlbumListComRespDto_2 != null && querySharedAlbumListComRespDto_2.getAlbumShareRecList() != null && !CollectionUtil.isEmpty(querySharedAlbumListComRespDto_2.getAlbumShareRecList())) {
                    receptionServiceReq_2.setAlbumList(//objList-to-objLists
                            querySharedAlbumListComRespDto_2.getAlbumShareRecList().stream().map(item -> {
                                AlbumDto elm = new AlbumDto();
                                if (item != null) {
                                    elm.setAlbumShareRecId(item.getAlbumShareRecId());//SimpleFieldAssign//sourceId:428131_2_73460
                                    elm.setAlbumId(item.getShareAlbumId());//SimpleFieldAssign//sourceId:427332_2_73460
                                    elm.setAlbumName(item.getAlbumName());//SimpleFieldAssign//sourceId:427333_2_73460
                                    elm.setAlbumThumbnail(item.getAlbumThumbnail());//SimpleFieldAssign//sourceId:427334_2_73460
                                    elm.setAlbumOwner(item.getShareObjectTypeCode());//SimpleFieldAssign//sourceId:427335_2_73460
                                    elm.setAlbumOwnerId(item.getShareObjectId());//SimpleFieldAssign//sourceId:427336_2_73460
                                    elm.setCopyRightOriginalRoleMemberId(item.getShareObjectOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427337_2_73460
                                    elm.setSharerName(item.getSharerName());//SimpleFieldAssign//sourceId:428117_2_73460
                                    elm.setRecipientName(item.getRecipientName());//SimpleFieldAssign//sourceId:428118_2_73460
                                    elm.setIsDefault(item.getIsDefault());//SimpleFieldAssign//sourceId:433453_2_73460
                                    elm.setCreateTime(item.getCreateTime());//SimpleFieldAssign//sourceId:427338_2_73460
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027109_1_73460
                }

                /*M8接收出参字段：专辑列表[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes_3 = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
        QueryPersonOrDeptAlbumListRespDto retData = new QueryPersonOrDeptAlbumListRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setAlbumList(receptionServiceRes_1.getAlbumList().stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027117_1
        }


        return retData;
    }

    /**
     * D8批量查询个人或部门名称[10352]
     * gen by moon at 11/11/2024, 2:00:41 AM
     */
    @Trace(operationName = "D8批量查询个人或部门名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryPersonOrDeptNameRespDto batchQueryPersonOrDeptName(BatchQueryPersonOrDeptNameReqDto reqDto) {


        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_ORG_DEPT"))) {
            //if(D8批量查询个人或部门名称.归属内容表类型编码 等于 部门表)  73461

            BatchQueryDeptComRespDto batchQueryDeptComRespDto = null;
            BatchQueryDeptComReqDto batchQueryDeptComReqDto = new BatchQueryDeptComReqDto();
            if (reqDto != null) {
                batchQueryDeptComReqDto.setDeptList(reqDto.getEntityIdList());//list-field-assign//sourceId:2027137_1_73463
            }

            /*D1批量查询部门(公共)[7511]   */

            batchQueryDeptComRespDto = orgService.batchQueryDeptCom(batchQueryDeptComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
            if (batchQueryDeptComRespDto != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (batchQueryDeptComRespDto != null && batchQueryDeptComRespDto.getDeptList() != null && !CollectionUtil.isEmpty(batchQueryDeptComRespDto.getDeptList())) {
                    receptionServiceReq.setEntityIdList(//objList-to-objLists
                            batchQueryDeptComRespDto.getDeptList().stream().map(item -> {
                                EntityIdDto elm = new EntityIdDto();
                                if (item != null) {
                                    elm.setEntityId(item.getDeptId());//SimpleFieldAssign//sourceId:427418_2_73466
                                    elm.setObjectName(item.getDeptShortName());//SimpleFieldAssign//sourceId:427424_2_73466
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027174_1_73466
                }

                /*M8接收出参字段[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_ORG_INDUCTION_RECORD"))) {
            //elseif(D8批量查询个人或部门名称.归属内容表类型编码 等于 就职记录表)  73462

            BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
            BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto = new BatchQueryInductionRecordListComReqDto();
            if (reqDto != null) {
                batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(reqDto.getEntityIdList());//list-field-assign//sourceId:2027170_1_73465
            }

            /*D1-3批量查询就职记录列表（公共）[602]   */

            batchQueryInductionRecordListComRespDto = inductionRecordService.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_2 = null;
            if (batchQueryInductionRecordListComRespDto != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq_1 = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (batchQueryInductionRecordListComRespDto != null && batchQueryInductionRecordListComRespDto.getPerOrgInductionRecordList() != null && !CollectionUtil.isEmpty(batchQueryInductionRecordListComRespDto.getPerOrgInductionRecordList())) {
                    receptionServiceReq_1.setEntityIdList(//objList-to-objLists
                            batchQueryInductionRecordListComRespDto.getPerOrgInductionRecordList().stream().map(item -> {
                                EntityIdDto elm = new EntityIdDto();
                                if (item != null) {
                                    elm.setEntityId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:427418_2_73467
                                    elm.setObjectName(item.getIdCardName());//SimpleFieldAssign//sourceId:427424_2_73467
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027174_1_73467
                }

                /*M8接收出参字段[10347]  用于特殊方法接收上游入参。 */

                receptionServiceRes_2 = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        BatchQueryPersonOrDeptNameRespDto retData = new BatchQueryPersonOrDeptNameRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setEntityIdList(receptionServiceRes_1.getEntityIdList().stream().map(item -> BeanUtil.toBean(item, EntityIdDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027177_1
        }


        return retData;
    }

    /**
     * D8查询回收站列表[10357]
     * gen by moon at 3/30/2025, 3:32:24 PM
     */
    @Trace(operationName = "D8查询回收站列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRecycleListRespDto queryRecycleList(QueryRecycleListReqDto reqDto) {


        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto_1 = null;
        BatchQueryAlbumComRespDto batchQueryAlbumComRespDto_1 = null;
//步骤0: D8查询专辑文件关系列表(公共) - queryAlbumFileRelationListCom
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028900_1
            queryAlbumFileRelationListComReqDto.setIsValid(reqDto.getIsValid());//SimpleFieldAssign//sourceId:2027226_1
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getCreateOwnerObjectId(), "D8查询回收站列表-D8查询专辑文件关系列表(公共)-创建于归属主体ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8查询回收站列表-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryAlbumFileRelationListComRespDto_1 = queryAlbumFileRelationListComRespDto;

//步骤1: D8批量查询专辑(公共) - batchQueryAlbumCom
        BatchQueryAlbumComRespDto batchQueryAlbumComRespDto = null;
        if (queryAlbumFileRelationListComRespDto != null) {
            BatchQueryAlbumComReqDto batchQueryAlbumComReqDto = new BatchQueryAlbumComReqDto();
            if (queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && !CollectionUtil.isEmpty(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList())) {
                batchQueryAlbumComReqDto.setAlbumList(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().stream().map(item -> item.getAlbumId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2027243_1
            }

            /*D8批量查询专辑(公共)[10331]   */

            batchQueryAlbumComRespDto = batchQueryAlbumCom(batchQueryAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


            batchQueryAlbumComRespDto_1 = batchQueryAlbumComRespDto;
        }

        QueryRecycleListRespDto retData = new QueryRecycleListRespDto();
        //数据集融合  MoreListToOneSource
        if (queryAlbumFileRelationListComRespDto_1 != null && !CollectionUtil.isEmpty(queryAlbumFileRelationListComRespDto_1.getAlbumFileRelationList())) {
            for (AlbumFileRelationDto albumFileRelationDto : queryAlbumFileRelationListComRespDto_1.getAlbumFileRelationList()) {
                AlbumFileRelationDto retElm = new AlbumFileRelationDto();
                if (queryAlbumFileRelationListComRespDto_1 != null) {
                    retElm.setAlbumRelationId(albumFileRelationDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:427477_2
                    retElm.setResourceFileId(albumFileRelationDto.getResourceFileId());//SimpleFieldAssign//sourceId:427771_2
                    retElm.setResourceFileAlias(albumFileRelationDto.getResourceFileAlias());//SimpleFieldAssign//sourceId:427466_2
                    retElm.setResourceFileSize(albumFileRelationDto.getResourceFileSize());//SimpleFieldAssign//sourceId:427467_2
                    retElm.setResourceFileExtension(albumFileRelationDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:427478_2
                }
                retData.getAlbumFileRelationList().add(retElm);
                if (batchQueryAlbumComRespDto_1 != null) {
                    for (AlbumDto albumDto : batchQueryAlbumComRespDto_1.getAlbumList()) {
                        if (albumDto.getAlbumId().equals(albumFileRelationDto.getAlbumId())) {
                            if (batchQueryAlbumComRespDto_1 != null) {
                                retElm.setAlbumName(albumDto.getAlbumName());//SimpleFieldAssign//sourceId:427468_2
                                retElm.setIsDefault(albumDto.getIsDefault());//SimpleFieldAssign//sourceId:433458_2
                            }
                        }
                    }
                }

            }
        }//sourceId:2027250_1


        return retData;
    }

    /**
     * D8删除专辑下文件(公共)[10359]
     * gen by moon at 5/27/2025, 1:42:09 PM
     */
    @Trace(operationName = "D8删除专辑下文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteFileOfAlbumComRespDto deleteFileOfAlbumCom(DeleteFileOfAlbumComReqDto reqDto) {


        //virtualUsage D8查询已作废的专辑文件关系列表(公共)  73485
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setIsValid("TRUE");//sourceId:2047850_1_73485
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027488_1_73485
        }

        /*D8查询已作废的专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileId(), "D8删除专辑下文件(公共)-D8查询已作废的专辑文件关系列表(公共)-资源文件ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8删除专辑下文件(公共)-D8查询已作废的专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8批量删专辑文件关系(公共)  74085
        BatchDeleteAlbumFileRelationComRespDto batchDeleteAlbumFileRelationComRespDto = null;
        if (queryAlbumFileRelationListComRespDto != null) {
            BatchDeleteAlbumFileRelationComReqDto batchDeleteAlbumFileRelationComReqDto = new BatchDeleteAlbumFileRelationComReqDto();
            if (queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && !CollectionUtil.isEmpty(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList())) {
                batchDeleteAlbumFileRelationComReqDto.setAlbumFileRelationList(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().stream().map(item -> item.getAlbumRelationId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2047866_1_74085
            }

            /*D8批量删专辑文件关系(公共)[10538]   */

            batchDeleteAlbumFileRelationComRespDto = batchDeleteAlbumFileRelationCom(batchDeleteAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


        }
//virtualUsage D8查询专辑文件关系列表(公共)  74086
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto_2 = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto_1 = new QueryAlbumFileRelationListComReqDto();
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto_1.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047867_1_74086
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto_1.getResourceFileId(), "D8删除专辑下文件(公共)-D8查询专辑文件关系列表(公共)-资源文件ID不能为空", false);
        queryAlbumFileRelationListComRespDto_2 = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto_1)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumFileRelationListComRespDto_2 != null && queryAlbumFileRelationListComRespDto_2.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto_2.getAlbumFileRelationList().size() == 0)) {
            //if(D8查询作废关系删除后的专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0)  73486

            QueryResourceFileDetailComRespDto queryResourceFileDetailComRespDto = null;
            QueryResourceFileDetailComReqDto queryResourceFileDetailComReqDto = new QueryResourceFileDetailComReqDto();
            if (reqDto != null) {
                queryResourceFileDetailComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027471_1_73487
            }

            /*D8查询资源文件详情(公共)[10321]   */
            Assert.isNull(queryResourceFileDetailComReqDto.getResourceFileId(), "D8删除专辑下文件(公共)-D8查询资源文件详情(公共)-资源文件ID不能为空", false);
            queryResourceFileDetailComRespDto = resourceFileService.queryResourceFileDetailCom(queryResourceFileDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryResourceFileDetailComRespDto != null && queryResourceFileDetailComRespDto.getResourceFileId() != null)) {
                //if(D8查询资源文件详情(公共).资源文件ID 值不等于空 )  73494

                ImplementSubjectLifeCycleJudgeComRespDto implementSubjectLifeCycleJudgeComRespDto = null;
                if (queryResourceFileDetailComRespDto != null) {
                    ImplementSubjectLifeCycleJudgeComReqDto implementSubjectLifeCycleJudgeComReqDto = new ImplementSubjectLifeCycleJudgeComReqDto();
                    implementSubjectLifeCycleJudgeComReqDto.setLifecyCycleOperationType("RECYLE_DELETE");//sourceId:2027460_1_73495
                    if (queryResourceFileDetailComRespDto != null) {
                        implementSubjectLifeCycleJudgeComReqDto.setIsValid(queryResourceFileDetailComRespDto.getIsValid());//SimpleFieldAssign//sourceId:2027461_1_73495
                    }

                    /*D8执行生命周期判断(公共)[10346]   */
                    Assert.isNull(implementSubjectLifeCycleJudgeComReqDto.getLifecyCycleOperationType(), "D8删除专辑下文件(公共)-D8执行生命周期判断(公共)-生命周期操作类型不能为空", false);
                    Assert.isNull(implementSubjectLifeCycleJudgeComReqDto.getIsValid(), "D8删除专辑下文件(公共)-D8执行生命周期判断(公共)-是否作废不能为空", false);
                    implementSubjectLifeCycleJudgeComRespDto = unstructuredResourcesService.implementSubjectLifeCycleJudgeCom(implementSubjectLifeCycleJudgeComReqDto)/*vcase invoke isSameApp*/;


                }
                QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
                com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("PLATFORM");//sourceId:2027517_1_73499
                queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("FILE_STORAGE_ROOT_PATH");//CUSTOM_CONVENTION//sourceId:2027518_1_73499
                queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:2027519_1_73499

                /*D2查物理文件根路径[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D8删除专辑下文件(公共)-D2查物理文件根路径-开通对象类型编码不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D8删除专辑下文件(公共)-D2查物理文件根路径-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D8删除专辑下文件(公共)-D2查物理文件根路径-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                DeleteResourceFileComRespDto deleteResourceFileComRespDto = null;
                DeleteResourceFileComReqDto deleteResourceFileComReqDto = new DeleteResourceFileComReqDto();
                if (reqDto != null) {
                    deleteResourceFileComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027265_1_73496
                }

                /*D8删除资源文件(公共)[10319]   */
                Assert.isNull(deleteResourceFileComReqDto.getResourceFileId(), "D8删除专辑下文件(公共)-D8删除资源文件(公共)-资源文件ID不能为空", false);
                deleteResourceFileComRespDto = resourceFileService.deleteResourceFileCom(deleteResourceFileComReqDto)/*vcase invoke isSameApp*/;


                DeletePhysicalResourceFileComRespDto deletePhysicalResourceFileComRespDto = null;
                if (queryConfItemMatchAnswerDetailComRespDto != null && queryResourceFileDetailComRespDto != null) {
                    DeletePhysicalResourceFileComReqDto deletePhysicalResourceFileComReqDto = new DeletePhysicalResourceFileComReqDto();
                    if (queryConfItemMatchAnswerDetailComRespDto != null) {
                        deletePhysicalResourceFileComReqDto.setFileStorageRootPath(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:2027285_1_73497
                    }
                    if (queryResourceFileDetailComRespDto != null) {
                        deletePhysicalResourceFileComReqDto.setResourceFileRelaPath(queryResourceFileDetailComRespDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2027286_1_73497
                    }

                    /*D8删除物理资源文件(公共)[10362]   */
                    Assert.isNull(deletePhysicalResourceFileComReqDto.getFileStorageRootPath(), "D8删除专辑下文件(公共)-D8删除物理资源文件(公共)-文件存储根路径不能为空", false);
                    Assert.isNull(deletePhysicalResourceFileComReqDto.getResourceFileRelaPath(), "D8删除专辑下文件(公共)-D8删除物理资源文件(公共)-资源文件相对路径不能为空", false);
                    deletePhysicalResourceFileComRespDto = resourceFileService.deletePhysicalResourceFileCom(deletePhysicalResourceFileComReqDto)/*vcase invoke isSameApp*/;


                }
            }
        } else if ((queryAlbumFileRelationListComRespDto_2 != null && queryAlbumFileRelationListComRespDto_2.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto_2.getAlbumFileRelationList().size() != 0)) {
            //elseif(D8查询作废关系删除后的专辑文件关系列表(公共).专辑文档关系列表数据集条数 不等于 0)  74087

//异常结束 74088
            throw new BizException("3R300100526", "对不起，这个文件已分享给他人使用中，请确认并处理后再删除~", false);
        }
        DeleteFileOfAlbumComRespDto retData = new DeleteFileOfAlbumComRespDto();


        return retData;
    }

    /**
     * D8查询专辑名称重复(公共)[10360]
     * gen by moon at 3/30/2025, 3:32:34 PM
     */
    @Trace(operationName = "D8查询专辑名称重复(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDuplicateAlbumNameDetailComRespDto queryDuplicateAlbumNameDetailCom(QueryDuplicateAlbumNameDetailComReqDto reqDto) {


        QueryAlbumListComRespDto queryAlbumListComRespDto_1 = null;
//步骤0: D8查询专辑列表(公共) - queryAlbumListCom
        QueryAlbumListComRespDto queryAlbumListComRespDto = null;
        QueryAlbumListComReqDto queryAlbumListComReqDto = new QueryAlbumListComReqDto();
        if (reqDto != null) {
            queryAlbumListComReqDto.setQuerySortTypeCode(reqDto.getQuerySortTypeCode());//SimpleFieldAssign//sourceId:2027275_1
            queryAlbumListComReqDto.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2027270_1
            queryAlbumListComReqDto.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2027271_1
            queryAlbumListComReqDto.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2027272_1
            queryAlbumListComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027273_1
            queryAlbumListComReqDto.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2043936_1
        }

        /*D8查询专辑列表(公共)[10329]   */
        Assert.isNull(queryAlbumListComReqDto.getQuerySortTypeCode(), "D8查询专辑名称重复(公共)-D8查询专辑列表(公共)-查询排序类型不能为空", false);
        Assert.isNull(queryAlbumListComReqDto.getAlbumOwner(), "D8查询专辑名称重复(公共)-D8查询专辑列表(公共)-版权归属类型不能为空", false);
        queryAlbumListComRespDto = queryAlbumListCom(queryAlbumListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryAlbumListComRespDto_1 = queryAlbumListComRespDto;

        QueryDuplicateAlbumNameDetailComRespDto retData = new QueryDuplicateAlbumNameDetailComRespDto();
        if (queryAlbumListComRespDto_1 != null) {
            retData.setAlbumList(queryAlbumListComRespDto_1.getAlbumList().stream().map(item -> BeanUtil.toBean(item, AlbumDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027284_1
        }


        return retData;
    }

    /**
     * D8复制专辑[10363]
     * gen by moon at 3/30/2025, 3:32:41 PM
     */
    @Trace(operationName = "D8复制专辑")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CopyAlbumRespDto copyAlbum(CopyAlbumReqDto reqDto) {


        //virtualUsage D8查询专辑名称重复(公共)  73468
        QueryDuplicateAlbumNameDetailComRespDto queryDuplicateAlbumNameDetailComRespDto = null;
        QueryDuplicateAlbumNameDetailComReqDto queryDuplicateAlbumNameDetailComReqDto = new QueryDuplicateAlbumNameDetailComReqDto();
        queryDuplicateAlbumNameDetailComReqDto.setQuerySortTypeCode("CREATE_TIME_DESC");//sourceId:2027302_1_73468
        if (reqDto != null) {
            queryDuplicateAlbumNameDetailComReqDto.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2027303_1_73468
            queryDuplicateAlbumNameDetailComReqDto.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2027304_1_73468
            queryDuplicateAlbumNameDetailComReqDto.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2027305_1_73468
            queryDuplicateAlbumNameDetailComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027306_1_73468
        }

        /*D8查询专辑名称重复(公共)[10360]   */
        Assert.isNull(queryDuplicateAlbumNameDetailComReqDto.getQuerySortTypeCode(), "D8复制专辑-D8查询专辑名称重复(公共)-查询排序类型不能为空", false);
        Assert.isNull(queryDuplicateAlbumNameDetailComReqDto.getAlbumName(), "D8复制专辑-D8查询专辑名称重复(公共)-专辑名称不能为空", false);
        Assert.isNull(queryDuplicateAlbumNameDetailComReqDto.getAlbumOwner(), "D8复制专辑-D8查询专辑名称重复(公共)-版权归属类型不能为空", false);
        Assert.isNull(queryDuplicateAlbumNameDetailComReqDto.getAlbumOwnerId(), "D8复制专辑-D8查询专辑名称重复(公共)-版权归属对象ID不能为空", false);
        queryDuplicateAlbumNameDetailComRespDto = queryDuplicateAlbumNameDetailCom(queryDuplicateAlbumNameDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryDuplicateAlbumNameDetailComRespDto != null && queryDuplicateAlbumNameDetailComRespDto.getAlbumList() != null && queryDuplicateAlbumNameDetailComRespDto.getAlbumList().size() > 0)) {
            //if(D8查询专辑名称重复列表(公共).专辑列表数据集条数 大于 0)  73469

//异常结束 73470
            throw new BizException("C00520", "对不起，专辑名称已存在~", false);
        }
//virtualUsage D8查询专辑详情(公共)  73475
        QueryAlbumDetailComRespDto queryAlbumDetailComRespDto = null;
        QueryAlbumDetailComReqDto queryAlbumDetailComReqDto = new QueryAlbumDetailComReqDto();
        if (reqDto != null) {
            queryAlbumDetailComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2027308_1_73475
        }

        /*D8查询专辑详情(公共)[10327]   */

        queryAlbumDetailComRespDto = queryAlbumDetailCom(queryAlbumDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8新增专辑(公共)  73476
        AddAlbumComRespDto addAlbumComRespDto = null;
        if (queryAlbumDetailComRespDto != null) {
            AddAlbumComReqDto addAlbumComReqDto = new AddAlbumComReqDto();
            addAlbumComReqDto.setIsDefault("FALSE");//sourceId:2043932_1_73476
            if (reqDto != null) {
                addAlbumComReqDto.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2027321_1_73476
                addAlbumComReqDto.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2027324_1_73476
                addAlbumComReqDto.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2027325_1_73476
                addAlbumComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2027326_1_73476
                addAlbumComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2027332_1_73476
            }
            if (queryAlbumDetailComRespDto != null) {
                addAlbumComReqDto.setAlbumDescribe(queryAlbumDetailComRespDto.getAlbumDescribe());//SimpleFieldAssign//sourceId:2027322_1_73476
                addAlbumComReqDto.setAlbumThumbnail(queryAlbumDetailComRespDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2027323_1_73476
                addAlbumComReqDto.setAlbumShareFromId(queryAlbumDetailComRespDto.getAlbumId());//SimpleFieldAssign//sourceId:2027327_1_73476
                addAlbumComReqDto.setIsShare(queryAlbumDetailComRespDto.getIsShare());//SimpleFieldAssign//sourceId:2027328_1_73476
            }

            /*D8新增专辑(公共)[10295]   */
            Assert.isNull(addAlbumComReqDto.getAlbumName(), "D8复制专辑-D8新增专辑(公共)-专辑名称不能为空", false);
            Assert.isNull(addAlbumComReqDto.getAlbumOwner(), "D8复制专辑-D8新增专辑(公共)-版权归属类型不能为空", false);
            Assert.isNull(addAlbumComReqDto.getAlbumOwnerId(), "D8复制专辑-D8新增专辑(公共)-版权归属对象ID不能为空", false);
            Assert.isNull(addAlbumComReqDto.getAlbumShareFromId(), "D8复制专辑-D8新增专辑(公共)-来源分享的专辑ID不能为空", false);
            Assert.isNull(addAlbumComReqDto.getIsShare(), "D8复制专辑-D8新增专辑(公共)-是否可分享不能为空", false);
            Assert.isNull(addAlbumComReqDto.getIsDefault(), "D8复制专辑-D8新增专辑(公共)-是否默认专辑不能为空", false);
            Assert.isNull(addAlbumComReqDto.getSubjectLifeCycle(), "D8复制专辑-D8新增专辑(公共)-主体生命周期不能为空", false);
            addAlbumComRespDto = addAlbumCom(addAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


        }
//virtualUsage D8查询专辑文件关系列表(公共)  73477
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2028967_1_73477
        queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2027360_1_73477
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2027353_1_73477
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getAlbumId(), "D8复制专辑-D8查询专辑文件关系列表(公共)-关联专辑ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getSubjectLifeCycle(), "D8复制专辑-D8查询专辑文件关系列表(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8复制专辑-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 0)) {
            //if(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0)  73492

//异常结束 73493
            throw new BizException("C00521", "对不起，复制来源专辑中文件为空不可复制。", false);
        } else {
            //else  73498

            BatchAddAlbumFileRelationComRespDto batchAddAlbumFileRelationComRespDto = null;
            if (queryAlbumFileRelationListComRespDto != null && addAlbumComRespDto != null) {
                BatchAddAlbumFileRelationComReqDto batchAddAlbumFileRelationComReqDto = new BatchAddAlbumFileRelationComReqDto();
                if (queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && !CollectionUtil.isEmpty(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList())) {
                    AddAlbumComRespDto finalAddAlbumComRespDto = addAlbumComRespDto;
                    batchAddAlbumFileRelationComReqDto.setAlbumFileRelationList(//objList-to-objLists
                            queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().stream().map(item -> {
                                AlbumFileRelationDto elm = new AlbumFileRelationDto();
                                if (item != null) {
                                    elm.setResourceFileId(item.getResourceFileId());//SimpleFieldAssign//sourceId:427751_2_73501
                                    elm.setResourceFileAlias(item.getResourceFileAlias());//SimpleFieldAssign//sourceId:427753_2_73501
                                    elm.setResourceFileName(item.getResourceFileName());//SimpleFieldAssign//sourceId:427754_2_73501
                                    elm.setResourceFileNumber(item.getResourceFileNumber());//SimpleFieldAssign//sourceId:427755_2_73501
                                    elm.setResourceFileType(item.getResourceFileType());//SimpleFieldAssign//sourceId:427756_2_73501
                                    elm.setResourceFileDetailType(item.getResourceFileDetailType());//SimpleFieldAssign//sourceId:427757_2_73501
                                    elm.setResourceFileRelaPath(item.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:427758_2_73501
                                    elm.setResourceFileSize(item.getResourceFileSize());//SimpleFieldAssign//sourceId:427759_2_73501
                                    elm.setResourceFileExtension(item.getResourceFileExtension());//SimpleFieldAssign//sourceId:427760_2_73501
                                    elm.setResourceCopyRightType(item.getResourceCopyRightType());//SimpleFieldAssign//sourceId:427761_2_73501
                                    elm.setResourceCopyRightHolderId(item.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:427762_2_73501
                                    elm.setCopyRightOriginalRoleMemberId(item.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:427763_2_73501
                                    elm.setCopyrightOwnerName(item.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:428091_2_73501
                                }
                                if (finalAddAlbumComRespDto != null) {
                                    elm.setAlbumId(finalAddAlbumComRespDto.getAlbumId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:427752_2_73501
                                }
                                if (reqDto != null) {
                                    elm.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:428165_2_73501
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2027582_1_73501
                }

                /*D8批量增专辑文件关系(公共)[10366]   */

                batchAddAlbumFileRelationComRespDto = batchAddAlbumFileRelationCom(batchAddAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        }
        CopyAlbumRespDto retData = new CopyAlbumRespDto();


        return retData;
    }

    /**
     * D8移除专辑下文件[10364]
     * gen by moon at 11/21/2024, 9:38:34 PM
     */
    @Trace(operationName = "D8移除专辑下文件")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RemoveFileOfAlbumRespDto removeFileOfAlbum(RemoveFileOfAlbumReqDto reqDto) {


        //virtualUsage D8查询专辑文件关系详情(公共)  73471
        QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailComRespDto = null;
        QueryAlbumFileRelationDetailComReqDto queryAlbumFileRelationDetailComReqDto = new QueryAlbumFileRelationDetailComReqDto();
        if (reqDto != null) {
            queryAlbumFileRelationDetailComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2027373_1_73471
        }

        /*D8查询专辑文件关系详情(公共)[10342]   */
        Assert.isNull(queryAlbumFileRelationDetailComReqDto.getAlbumRelationId(), "D8移除专辑下文件-D8查询专辑文件关系详情(公共)-专辑文档关系ID不能为空", false);
        queryAlbumFileRelationDetailComRespDto = queryAlbumFileRelationDetailCom(queryAlbumFileRelationDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8执行生命周期判断(公共)  73472
        ImplementSubjectLifeCycleJudgeComRespDto implementSubjectLifeCycleJudgeComRespDto = null;
        if (queryAlbumFileRelationDetailComRespDto != null) {
            ImplementSubjectLifeCycleJudgeComReqDto implementSubjectLifeCycleJudgeComReqDto = new ImplementSubjectLifeCycleJudgeComReqDto();
            implementSubjectLifeCycleJudgeComReqDto.setLifecyCycleOperationType("INVALIDATE");//sourceId:2027480_1_73472
            if (queryAlbumFileRelationDetailComRespDto != null) {
                implementSubjectLifeCycleJudgeComReqDto.setSubjectLifeCycle(queryAlbumFileRelationDetailComRespDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2027481_1_73472
                implementSubjectLifeCycleJudgeComReqDto.setIsValid(queryAlbumFileRelationDetailComRespDto.getIsValid());//SimpleFieldAssign//sourceId:2027482_1_73472
            }

            /*D8执行生命周期判断(公共)[10346]   */
            Assert.isNull(implementSubjectLifeCycleJudgeComReqDto.getLifecyCycleOperationType(), "D8移除专辑下文件-D8执行生命周期判断(公共)-生命周期操作类型不能为空", false);
            implementSubjectLifeCycleJudgeComRespDto = unstructuredResourcesService.implementSubjectLifeCycleJudgeCom(implementSubjectLifeCycleJudgeComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage D8修改专辑文件关系(公共)  73473
        UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
        UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
        updateAlbumFileRelationComReqDto.setIsValid("TRUE");//sourceId:2027343_1_73473
        if (reqDto != null) {
            updateAlbumFileRelationComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2027341_1_73473
        }

        /*D8修改专辑文件关系(公共)[10325]   */
        Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8移除专辑下文件-D8修改专辑文件关系(公共)-专辑文档关系ID不能为空", false);
        Assert.isNull(updateAlbumFileRelationComReqDto.getIsValid(), "D8移除专辑下文件-D8修改专辑文件关系(公共)-是否作废不能为空", false);
        updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8查询专辑文件关系列表(公共)  73474
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2027403_1_73474
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027402_1_73474
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileId(), "D8移除专辑下文件-D8查询专辑文件关系列表(公共)-资源文件ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8移除专辑下文件-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 0)) {
            //if(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0)  73478

            QueryResourceFileDetailComRespDto queryResourceFileDetailComRespDto = null;
            QueryResourceFileDetailComReqDto queryResourceFileDetailComReqDto = new QueryResourceFileDetailComReqDto();
            if (reqDto != null) {
                queryResourceFileDetailComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027369_1_73479
            }

            /*D8查询资源文件详情(公共)[10321]   */
            Assert.isNull(queryResourceFileDetailComReqDto.getResourceFileId(), "D8移除专辑下文件-D8查询资源文件详情(公共)-资源文件ID不能为空", false);
            queryResourceFileDetailComRespDto = resourceFileService.queryResourceFileDetailCom(queryResourceFileDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryResourceFileDetailComRespDto != null && queryResourceFileDetailComRespDto.getResourceFileId() != null)) {
                //if(D8查询资源文件详情(公共).资源文件ID 值不等于空 )  73489

                ImplementSubjectLifeCycleJudgeComRespDto implementSubjectLifeCycleJudgeComRespDto_1 = null;
                if (queryResourceFileDetailComRespDto != null) {
                    ImplementSubjectLifeCycleJudgeComReqDto implementSubjectLifeCycleJudgeComReqDto_1 = new ImplementSubjectLifeCycleJudgeComReqDto();
                    implementSubjectLifeCycleJudgeComReqDto_1.setLifecyCycleOperationType("INVALIDATE");//sourceId:2027480_1_73490
                    if (queryResourceFileDetailComRespDto != null) {
                        implementSubjectLifeCycleJudgeComReqDto_1.setIsValid(queryResourceFileDetailComRespDto.getIsValid());//SimpleFieldAssign//sourceId:2027482_1_73490
                    }

                    /*D8执行生命周期判断(公共)[10346]   */
                    Assert.isNull(implementSubjectLifeCycleJudgeComReqDto_1.getLifecyCycleOperationType(), "D8移除专辑下文件-D8执行生命周期判断(公共)-生命周期操作类型不能为空", false);
                    implementSubjectLifeCycleJudgeComRespDto_1 = unstructuredResourcesService.implementSubjectLifeCycleJudgeCom(implementSubjectLifeCycleJudgeComReqDto_1)/*vcase invoke isSameApp*/;


                }
                UpdateResourceFileComRespDto updateResourceFileComRespDto = null;
                UpdateResourceFileComReqDto updateResourceFileComReqDto = new UpdateResourceFileComReqDto();
                updateResourceFileComReqDto.setIsValid("TRUE");//sourceId:2027351_1_73491
                if (reqDto != null) {
                    updateResourceFileComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027352_1_73491
                }

                /*D8修改资源文件(公共)[10317]   */
                Assert.isNull(updateResourceFileComReqDto.getResourceFileId(), "D8移除专辑下文件-D8修改资源文件(公共)-资源文件ID不能为空", false);
                Assert.isNull(updateResourceFileComReqDto.getIsValid(), "D8移除专辑下文件-D8修改资源文件(公共)-是否作废不能为空", false);
                updateResourceFileComRespDto = resourceFileService.updateResourceFileCom(updateResourceFileComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        RemoveFileOfAlbumRespDto retData = new RemoveFileOfAlbumRespDto();


        return retData;
    }

    /**
     * D8批量增专辑文件关系(公共)[10366]
     * gen by moon at 11/21/2024, 10:01:07 PM
     */
    @Trace(operationName = "D8批量增专辑文件关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchAddAlbumFileRelationComRespDto batchAddAlbumFileRelationCom(BatchAddAlbumFileRelationComReqDto reqDto) {


        //步骤0: 8-02-04批量增专辑文件关系 - batchAddAlbumFileRelation
        boolean bOOLEAN;
        List<OmsAlbumFileRelation> listOmsAlbumFileRelation = new ArrayList<>();
        if (reqDto != null && reqDto.getAlbumFileRelationList() != null && !CollectionUtil.isEmpty(reqDto.getAlbumFileRelationList())) {
            listOmsAlbumFileRelation = reqDto.getAlbumFileRelationList().stream().map(item -> BeanUtil.toBean(item, OmsAlbumFileRelation.class)).collect(Collectors.toList());//objList-to-objLists//sourceId:2027580_1
        }

        /*8-02-04批量增专辑文件关系[10368]   */

        bOOLEAN = mOmsAlbumFileRelationService.batchAddAlbumFileRelation(listOmsAlbumFileRelation)/*vcase invoke 本地 method 方法调用;*/;


        BatchAddAlbumFileRelationComRespDto retData = new BatchAddAlbumFileRelationComRespDto();


        return retData;
    }

    /**
     * D8执行新增文件及专辑文件关系[10377]
     * gen by moon at 11/14/2024, 10:36:38 AM
     */
    @Trace(operationName = "D8执行新增文件及专辑文件关系")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAlbumFileRelationRespDto implementAlbumFileRelation(ImplementAlbumFileRelationReqDto reqDto) {


        //virtualUsage M8执行资源文件【循环开始】  73527
        //ModelCode: circulationCollections
        for (Object circulationCollectionsRes : new ArrayList()) { //设计工具未关联参数,请联系调整

//virtualUsage M8执行【循环结束】  73528
            //ModelCode: circulationEnd
        }

        ImplementAlbumFileRelationRespDto retData = new ImplementAlbumFileRelationRespDto();


        return retData;
    }

    /**
     * D8修改存档专辑操作[10353]
     * gen by moon at 11/16/2024, 3:33:40 PM
     */
    @Trace(operationName = "D8修改存档专辑操作")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateArchiveAlbumOperRespDto updateArchiveAlbumOper(UpdateArchiveAlbumOperReqDto reqDto) {


        //virtualUsage D8查询专辑文件关系列表(公共)  73549
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setIsArchive("FALSE");//sourceId:2028476_1_73549
        queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2028468_1_73549
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2028461_1_73549
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getAlbumId(), "D8修改存档专辑操作-D8查询专辑文件关系列表(公共)-关联专辑ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsArchive(), "D8修改存档专辑操作-D8查询专辑文件关系列表(公共)-是否存档不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8修改存档专辑操作-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        if (CollectionUtil.isEmpty(queryAlbumFileRelationListComRespDto.getAlbumFileRelationList())) {
            //if(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0)  73550

            UpdateAlbumComRespDto updateAlbumComRespDto = null;
            UpdateAlbumComReqDto updateAlbumComReqDto = new UpdateAlbumComReqDto();
            updateAlbumComReqDto.setSubjectLifeCycle("ARCHIVING");//sourceId:2028455_1_73551
            updateAlbumComReqDto.setIsArchive("TRUE");//sourceId:2027189_1_73551
            if (reqDto != null) {
                updateAlbumComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2027181_1_73551
            }

            /*D8修改专辑(公共)[10322]   */
            Assert.isNull(updateAlbumComReqDto.getAlbumId(), "D8修改存档专辑操作-D8修改专辑(公共)-专辑ID不能为空", false);
            Assert.isNull(updateAlbumComReqDto.getSubjectLifeCycle(), "D8修改存档专辑操作-D8修改专辑(公共)-主体生命周期不能为空", false);
            Assert.isNull(updateAlbumComReqDto.getIsArchive(), "D8修改存档专辑操作-D8修改专辑(公共)-是否存档不能为空", false);
            updateAlbumComRespDto = updateAlbumCom(updateAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


        } else {
            //else  73554

//异常结束 73555
            throw new BizException("3R300100522", "对不起，专辑下还有未存档的文件，请存档后再试~", false);
        }
        UpdateArchiveAlbumOperRespDto retData = new UpdateArchiveAlbumOperRespDto();


        return retData;
    }

    /**
     * D8新增专辑文件关系[10388]
     * gen by moon at 12/17/2024, 7:39:24 PM
     */
    @Trace(operationName = "D8新增专辑文件关系")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoopAddAlbumFileRelationRespDto loopAddAlbumFileRelation(LoopAddAlbumFileRelationReqDto reqDto) {


        //virtualUsage D2查询上传类型（空间）  73709
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034312_1_73709
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2034313_1_73709
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("UPLOAD_TYPE");//CUSTOM_CONVENTION//sourceId:2034314_1_73709
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:2034315_1_73709

        /*D2查询上传类型（空间）[2486]   */

        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        //virtualUsage M8执行资源文件【循环开始】  73566
        //ModelCode: circulationCollections
        for (ResourceFileDto circulationCollectionsRes : reqDto.getResourceFileList()) {

            if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("LOCAL_MODEL"))) {
                //if(D2查询上传类型（空间）.答案值 等于 本地模式)  73567

                AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto = null;
                AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto = new AddAlbumFileRelationComReqDto();
                if (circulationCollectionsRes != null) {
                    addAlbumFileRelationComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2028821_1_73619
                }
                if (reqDto != null) {
                    addAlbumFileRelationComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2028822_1_73619
                    addAlbumFileRelationComReqDto.setCopyrightOwnerName(reqDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2028872_1_73619
                    addAlbumFileRelationComReqDto.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028903_1_73619
                }

                /*D8新增专辑文件关系(公共)[10324]   */
                Assert.isNull(addAlbumFileRelationComReqDto.getResourceFileId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getAlbumId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getCreateOwnerObjectId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                addAlbumFileRelationComRespDto = addAlbumFileRelationCom(addAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            } else {
                //else  73617

                QueryDocumentTypeAnswerDetailComRespDto queryDocumentTypeAnswerDetailComRespDto = null;
                QueryDocumentTypeAnswerDetailComReqDto queryDocumentTypeAnswerDetailComReqDto = new QueryDocumentTypeAnswerDetailComReqDto();
                queryDocumentTypeAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2031253_1_73624
                queryDocumentTypeAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2031254_1_73624
                queryDocumentTypeAnswerDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2031255_1_73624
                if (circulationCollectionsRes != null) {
                    queryDocumentTypeAnswerDetailComReqDto.setConfItemCode(circulationCollectionsRes.getResourceFileExtension());//SimpleFieldAssign//sourceId:2031248_1_73624
                }

                /*D2-3查询文档类型配置答案详情(公共)[2458]   */
                Assert.isNull(queryDocumentTypeAnswerDetailComReqDto.getResultAspObjId(), "D8新增专辑文件关系-D2-3查询文档类型配置答案详情(公共)-开通对象ID不能为空", false);
                Assert.isNull(queryDocumentTypeAnswerDetailComReqDto.getConfItemCode(), "D8新增专辑文件关系-D2-3查询文档类型配置答案详情(公共)-配置项标识不能为空", false);
                Assert.isNull(queryDocumentTypeAnswerDetailComReqDto.getResultAspObjType(), "D8新增专辑文件关系-D2-3查询文档类型配置答案详情(公共)-开通对象类型编码不能为空", false);
                Assert.isNull(queryDocumentTypeAnswerDetailComReqDto.getSubjectLifeCycle(), "D8新增专辑文件关系-D2-3查询文档类型配置答案详情(公共)-主体生命周期不能为空", false);
                queryDocumentTypeAnswerDetailComRespDto = confSchemeService.queryDocumentTypeAnswerDetailCom(queryDocumentTypeAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                AddResourceFileComRespDto addResourceFileComRespDto = null;
                if (queryDocumentTypeAnswerDetailComRespDto != null) {
                    AddResourceFileComReqDto addResourceFileComReqDto = new AddResourceFileComReqDto();
                    if (circulationCollectionsRes != null) {
                        addResourceFileComReqDto.setHashCode(circulationCollectionsRes.getHashCode());//SimpleFieldAssign//sourceId:2036914_1_73620
                        addResourceFileComReqDto.setResourceFileName(circulationCollectionsRes.getResourceFileName());//SimpleFieldAssign//sourceId:2029943_1_73620
                        addResourceFileComReqDto.setResourceFileRelaPath(circulationCollectionsRes.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2029945_1_73620
                        addResourceFileComReqDto.setResourceFileSize(circulationCollectionsRes.getResourceFileSize());//SimpleFieldAssign//sourceId:2029946_1_73620
                        addResourceFileComReqDto.setResourceFileExtension(circulationCollectionsRes.getResourceFileExtension());//SimpleFieldAssign//sourceId:2029947_1_73620
                        addResourceFileComReqDto.setResourceCopyRightType(circulationCollectionsRes.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2029950_1_73620
                        addResourceFileComReqDto.setResourceCopyRightHolderId(circulationCollectionsRes.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2029951_1_73620
                        addResourceFileComReqDto.setCopyRightOriginalRoleMemberId(circulationCollectionsRes.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2029952_1_73620
                        addResourceFileComReqDto.setIsUserUpload(circulationCollectionsRes.getIsUserUpload());//SimpleFieldAssign//sourceId:2029955_1_73620
                        addResourceFileComReqDto.setIsEvi(circulationCollectionsRes.getIsEvi());//SimpleFieldAssign//sourceId:2029953_1_73620
                    }
                    if (queryDocumentTypeAnswerDetailComRespDto != null) {
                        addResourceFileComReqDto.setResourceFileType(queryDocumentTypeAnswerDetailComRespDto.getExtensionField1());//SimpleFieldAssign//sourceId:2029948_1_73620
                        addResourceFileComReqDto.setResourceFileDetailType(queryDocumentTypeAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:2029949_1_73620
                    }

                    /*D8新增资源文件(公共)[10316]   */
                    Assert.isNull(addResourceFileComReqDto.getResourceFileName(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件名称不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceFileRelaPath(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件相对路径不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceFileSize(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件大小不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceFileExtension(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件后缀不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceFileType(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件类型不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceFileDetailType(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件明细类型不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceCopyRightType(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件版权归属类型不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getResourceCopyRightHolderId(), "D8新增专辑文件关系-D8新增资源文件(公共)-资源文件版权归属对象ID不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getIsUserUpload(), "D8新增专辑文件关系-D8新增资源文件(公共)-是否来自个人网盘文件不能为空", false);
                    Assert.isNull(addResourceFileComReqDto.getIsEvi(), "D8新增专辑文件关系-D8新增资源文件(公共)-是否有存证不能为空", false);
                    addResourceFileComRespDto = resourceFileService.addResourceFileCom(addResourceFileComReqDto)/*vcase invoke isSameApp*/;


                }
                GenerateSmartIntroComRespDto generateSmartIntroComRespDto = null;
                if (addResourceFileComRespDto != null) {
                    GenerateSmartIntroComReqDto generateSmartIntroComReqDto = new GenerateSmartIntroComReqDto();
                    if (addResourceFileComRespDto != null) {
                        generateSmartIntroComReqDto.setResourceFileId(addResourceFileComRespDto.getResourceFileId());//SimpleFieldAssign//sourceId:2037084_1_73803
                    }
                    if (circulationCollectionsRes != null) {
                        generateSmartIntroComReqDto.setResourceFileRelaPath(circulationCollectionsRes.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2037085_1_73803
                    }

                    /*D8生成智能简介(公共)[10453]   */
                    Assert.isNull(generateSmartIntroComReqDto.getResourceFileId(), "D8新增专辑文件关系-D8生成智能简介(公共)-资源文件ID不能为空", false);
                    Assert.isNull(generateSmartIntroComReqDto.getResourceFileRelaPath(), "D8新增专辑文件关系-D8生成智能简介(公共)-资源文件相对路径不能为空", false);
                    generateSmartIntroComRespDto = resourceFileService.generateSmartIntroCom(generateSmartIntroComReqDto)/*vcase invoke isSameApp*/;


                }
                AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto_2 = null;
                if (addResourceFileComRespDto != null) {
                    AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto_1 = new AddAlbumFileRelationComReqDto();
                    if (addResourceFileComRespDto != null) {
                        addAlbumFileRelationComReqDto_1.setResourceFileId(addResourceFileComRespDto.getResourceFileId());//SimpleFieldAssign//sourceId:2028821_1_73621
                    }
                    if (reqDto != null) {
                        addAlbumFileRelationComReqDto_1.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2028822_1_73621
                        addAlbumFileRelationComReqDto_1.setCopyrightOwnerName(reqDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2028872_1_73621
                        addAlbumFileRelationComReqDto_1.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2028903_1_73621
                    }

                    /*D8新增专辑文件关系(公共)[10324]   */
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getResourceFileId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getAlbumId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getCreateOwnerObjectId(), "D8新增专辑文件关系-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                    addAlbumFileRelationComRespDto_2 = addAlbumFileRelationCom(addAlbumFileRelationComReqDto_1)/*vcase invoke 同服务,同domain*/;


                }
            }
//virtualUsage D2删除REDIS物理文件记录(redis)(公共)  73628
            DeletePhyFileRedisRecordComRespDto deletePhyFileRedisRecordComRespDto = null;
            DeletePhyFileRedisRecordComReqDto deletePhyFileRedisRecordComReqDto = new DeletePhyFileRedisRecordComReqDto();
            if (reqDto != null) {
                deletePhyFileRedisRecordComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031279_1_73628
            }
            if (circulationCollectionsRes != null) {
                deletePhyFileRedisRecordComReqDto.setPhyFilePath(circulationCollectionsRes.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2031280_1_73628
            }

            /*D2删除REDIS物理文件记录(redis)(公共)[10407]   */
            Assert.isNull(deletePhyFileRedisRecordComReqDto.getSpaceId(), "D8新增专辑文件关系-D2删除REDIS物理文件记录(redis)(公共)-租户标识不能为空", false);
            Assert.isNull(deletePhyFileRedisRecordComReqDto.getPhyFilePath(), "D8新增专辑文件关系-D2删除REDIS物理文件记录(redis)(公共)-物理文件路径不能为空", false);
            deletePhyFileRedisRecordComRespDto = fwCompResourceFileClient.deletePhyFileRedisRecordCom(deletePhyFileRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M8执行【循环结束】  73623
            //ModelCode: circulationEnd
        }


        LoopAddAlbumFileRelationRespDto retData = new LoopAddAlbumFileRelationRespDto();


        return retData;
    }

    /**
     * D8初始化默认专辑(公共)[10512]
     * gen by moon at 5/11/2025, 1:44:03 PM
     */
    @Trace(operationName = "D8初始化默认专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public InitDefaultAlbumComRespDto initDefaultAlbumCom(InitDefaultAlbumComReqDto reqDto) {


        //virtualUsage D8查询专辑详情(公共)  73989
        QueryAlbumDetailComRespDto queryAlbumDetailComRespDto = null;
        QueryAlbumDetailComReqDto queryAlbumDetailComReqDto = new QueryAlbumDetailComReqDto();
        queryAlbumDetailComReqDto.setIsDefault("TRUE");//sourceId:2043965_1_73989
        if (reqDto != null) {
            queryAlbumDetailComReqDto.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2043966_1_73989
            queryAlbumDetailComReqDto.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2043967_1_73989
            queryAlbumDetailComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2043968_1_73989
        }

        /*D8查询专辑详情(公共)[10327]   */
        Assert.isNull(queryAlbumDetailComReqDto.getAlbumOwner(), "D8初始化默认专辑(公共)-D8查询专辑详情(公共)-版权归属类型不能为空", false);
        Assert.isNull(queryAlbumDetailComReqDto.getIsDefault(), "D8初始化默认专辑(公共)-D8查询专辑详情(公共)-是否默认专辑不能为空", false);
        queryAlbumDetailComRespDto = queryAlbumDetailCom(queryAlbumDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8分析专辑归属对象ID(公共)  74039
        AnalyzeAlbumOwnershipIdRespDto analyzeAlbumOwnershipIdRespDto = null;
        AnalyzeAlbumOwnershipIdReqDto analyzeAlbumOwnershipIdReqDto = new AnalyzeAlbumOwnershipIdReqDto();
        if (reqDto != null) {
            analyzeAlbumOwnershipIdReqDto.setTableTypeCode(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2047142_1_74039
            analyzeAlbumOwnershipIdReqDto.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2047143_1_74039
        }

        /*D8分析专辑归属对象ID(公共)[10527]   */
        Assert.isNull(analyzeAlbumOwnershipIdReqDto.getTableTypeCode(), "D8初始化默认专辑(公共)-D8分析专辑归属对象ID(公共)-归属内容表类型编码不能为空", false);
        analyzeAlbumOwnershipIdRespDto = analyzeAlbumOwnershipId(analyzeAlbumOwnershipIdReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumDetailComRespDto != null && queryAlbumDetailComRespDto.getAlbumId() == null)) {
            //if(D8查询专辑详情(公共).专辑ID 值等于空 )  73990

            AddDefaultAlbumComRespDto addDefaultAlbumComRespDto = null;
            if (queryAlbumDetailComRespDto != null && analyzeAlbumOwnershipIdRespDto != null) {
                AddDefaultAlbumComReqDto addDefaultAlbumComReqDto = new AddDefaultAlbumComReqDto();
                addDefaultAlbumComReqDto.setAlbumName("默认专辑");//CUSTOM_CONVENTION//sourceId:2045547_1_74024
                addDefaultAlbumComReqDto.setIsShare("FALSE");//sourceId:2045554_1_74024
                addDefaultAlbumComReqDto.setIsDefault("TRUE");//sourceId:2045555_1_74024
                addDefaultAlbumComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2045557_1_74024
                if (queryAlbumDetailComRespDto != null) {
                    addDefaultAlbumComReqDto.setAlbumDescribe(queryAlbumDetailComRespDto.getAlbumDescribe());//SimpleFieldAssign//sourceId:2045548_1_74024
                    addDefaultAlbumComReqDto.setAlbumThumbnail(queryAlbumDetailComRespDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2045549_1_74024
                }
                if (reqDto != null) {
                    addDefaultAlbumComReqDto.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2045550_1_74024
                    addDefaultAlbumComReqDto.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2045552_1_74024
                }
                if (analyzeAlbumOwnershipIdRespDto != null) {
                    addDefaultAlbumComReqDto.setAlbumOwnerId(analyzeAlbumOwnershipIdRespDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2045551_1_74024
                }

                /*D8新增默认专辑(公共)[10523]   */
                Assert.isNull(addDefaultAlbumComReqDto.getAlbumName(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-专辑名称不能为空", false);
                Assert.isNull(addDefaultAlbumComReqDto.getAlbumOwner(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-版权归属类型不能为空", false);
                Assert.isNull(addDefaultAlbumComReqDto.getAlbumOwnerId(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-版权归属对象ID不能为空", false);
                Assert.isNull(addDefaultAlbumComReqDto.getIsShare(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-是否可分享不能为空", false);
                Assert.isNull(addDefaultAlbumComReqDto.getIsDefault(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-是否默认专辑不能为空", false);
                Assert.isNull(addDefaultAlbumComReqDto.getSubjectLifeCycle(), "D8初始化默认专辑(公共)-D8新增默认专辑(公共)-主体生命周期不能为空", false);
                addDefaultAlbumComRespDto = addDefaultAlbumCom(addDefaultAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        }
        InitDefaultAlbumComRespDto retData = new InitDefaultAlbumComRespDto();


        return retData;
    }

    /**
     * D8移动文件到指定专辑[10513]
     * gen by moon at 4/1/2025, 11:16:53 PM
     */
    @Trace(operationName = "D8移动文件到指定专辑")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public MoveFilesToSpecAlbumRespDto moveFilesToSpecAlbum(MoveFilesToSpecAlbumReqDto reqDto) {


        //virtualUsage M8执行专辑文件关系【循环开始】  73993
        //ModelCode: circulationCollections
        for (AlbumFileRelationDto circulationCollectionsRes : reqDto.getAlbumFileRelationList()) {

//virtualUsage D8查询专辑文件关系详情(通用)（公共）  74004
            QueryAlbumFileRelationDetailCommonComRespDto queryAlbumFileRelationDetailCommonComRespDto = null;
            QueryAlbumFileRelationDetailCommonComReqDto queryAlbumFileRelationDetailCommonComReqDto = new QueryAlbumFileRelationDetailCommonComReqDto();
            if (reqDto != null) {
                queryAlbumFileRelationDetailCommonComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2044154_1_74004
            }
            if (circulationCollectionsRes != null) {
                queryAlbumFileRelationDetailCommonComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2044153_1_74004
            }

            /*D8查询专辑文件关系详情(通用)（公共）[10517]   */
            Assert.isNull(queryAlbumFileRelationDetailCommonComReqDto.getAlbumId(), "D8移动文件到指定专辑-D8查询专辑文件关系详情(通用)（公共）-关联专辑ID不能为空", false);
            Assert.isNull(queryAlbumFileRelationDetailCommonComReqDto.getResourceFileId(), "D8移动文件到指定专辑-D8查询专辑文件关系详情(通用)（公共）-资源文件ID不能为空", false);
            queryAlbumFileRelationDetailCommonComRespDto = queryAlbumFileRelationDetailCommonCom(queryAlbumFileRelationDetailCommonComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((queryAlbumFileRelationDetailCommonComRespDto != null && queryAlbumFileRelationDetailCommonComRespDto.getAlbumRelationId() == null)) {
                //if(D8查询专辑文件关系详情(通用)（公共）.专辑文档关系ID 值等于空 )  73995

                UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
                UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
                if (circulationCollectionsRes != null) {
                    updateAlbumFileRelationComReqDto.setAlbumRelationId(circulationCollectionsRes.getAlbumRelationId());//SimpleFieldAssign//sourceId:2044019_1_73996
                }
                if (reqDto != null) {
                    updateAlbumFileRelationComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2044024_1_73996
                }

                /*D8修改专辑文件关系(公共)[10325]   */
                Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8移动文件到指定专辑-D8修改专辑文件关系(公共)-专辑文档关系ID不能为空", false);
                Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumId(), "D8移动文件到指定专辑-D8修改专辑文件关系(公共)-关联专辑ID不能为空", false);
                updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            }
//virtualUsage M8执行【循环结束】  73997
            //ModelCode: circulationEnd
        }

        MoveFilesToSpecAlbumRespDto retData = new MoveFilesToSpecAlbumRespDto();


        return retData;
    }

    /**
     * D8复制或移动文件到指定专辑[10515]
     * gen by moon at 6/4/2025, 9:21:12 PM
     */
    @Trace(operationName = "D8复制或移动文件到指定专辑")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CopyFilesToSpecAlbumRespDto copyFilesToSpecAlbum(CopyFilesToSpecAlbumReqDto reqDto) {


        //virtualUsage M8约定是否作废：否  74096
        //ModelCode: receptionService
        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
        ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
        receptionServiceReq.setIsValid("FALSE");//sourceId:2048802_1_74096

        /*M8约定是否作废：否[10347]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getIsValid(), "D8复制或移动文件到指定专辑-M8约定是否作废：否-是否作废不能为空", false);
        receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


        //virtualUsage M8执行专辑文件关系【循环开始】  74002
        //ModelCode: circulationCollections
        for (AlbumFileRelationDto circulationCollectionsRes : reqDto.getAlbumFileRelationList()) {

//virtualUsage D8查询专辑文件关系列表(公共)  74057
            QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
            QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
            queryAlbumFileRelationListComReqDto.setIsArchive("FALSE");//sourceId:2047387_1_74057
            queryAlbumFileRelationListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2047388_1_74057
            queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2047389_1_74057
            if (circulationCollectionsRes != null) {
                queryAlbumFileRelationListComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2047385_1_74057
            }
            if (reqDto != null) {
                queryAlbumFileRelationListComReqDto.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047386_1_74057
            }

            /*D8查询专辑文件关系列表(公共)[10330]   */
            Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileId(), "D8复制或移动文件到指定专辑-D8查询专辑文件关系列表(公共)-资源文件ID不能为空", false);
            Assert.isNull(queryAlbumFileRelationListComReqDto.getCreateOwnerObjectId(), "D8复制或移动文件到指定专辑-D8查询专辑文件关系列表(公共)-创建于归属主体ID不能为空", false);
            Assert.isNull(queryAlbumFileRelationListComReqDto.getIsArchive(), "D8复制或移动文件到指定专辑-D8查询专辑文件关系列表(公共)-是否存档不能为空", false);
            Assert.isNull(queryAlbumFileRelationListComReqDto.getSubjectLifeCycle(), "D8复制或移动文件到指定专辑-D8查询专辑文件关系列表(公共)-主体生命周期不能为空", false);
            Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8复制或移动文件到指定专辑-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
            queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8查询文件与指定专辑的关系是否已经存在  74005
            QueryAlbumFileRelationDetailCommonComRespDto queryAlbumFileRelationDetailCommonComRespDto = null;
            QueryAlbumFileRelationDetailCommonComReqDto queryAlbumFileRelationDetailCommonComReqDto = new QueryAlbumFileRelationDetailCommonComReqDto();
            if (circulationCollectionsRes != null) {
                queryAlbumFileRelationDetailCommonComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2047437_1_74005
            }
            if (reqDto != null) {
                queryAlbumFileRelationDetailCommonComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2047438_1_74005
            }

            /*D8查询文件与指定专辑的关系是否已经存在[10517]   */
            Assert.isNull(queryAlbumFileRelationDetailCommonComReqDto.getResourceFileId(), "D8复制或移动文件到指定专辑-D8查询文件与指定专辑的关系是否已经存在-资源文件ID不能为空", false);
            Assert.isNull(queryAlbumFileRelationDetailCommonComReqDto.getAlbumId(), "D8复制或移动文件到指定专辑-D8查询文件与指定专辑的关系是否已经存在-关联专辑ID不能为空", false);
            queryAlbumFileRelationDetailCommonComRespDto = queryAlbumFileRelationDetailCommonCom(queryAlbumFileRelationDetailCommonComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((queryAlbumFileRelationDetailCommonComRespDto != null && queryAlbumFileRelationDetailCommonComRespDto.getAlbumRelationId() == null && queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() > 1)) {
                //if((D8查询指定专辑与文件关系是否已存在.专辑文档关系ID 值等于空  and D8查询归属主体当前有效的专辑文件关系列表（非1条关系：非默认专辑；1条关系：判断是否默认专辑）.专辑文档关系列表数据集条数 大于 1))  73999

                AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto = null;
                AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto = new AddAlbumFileRelationComReqDto();
                if (circulationCollectionsRes != null) {
                    addAlbumFileRelationComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2044053_1_74001
                }
                if (reqDto != null) {
                    addAlbumFileRelationComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2044054_1_74001
                    addAlbumFileRelationComReqDto.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2044057_1_74001
                    addAlbumFileRelationComReqDto.setCopyrightOwnerName(reqDto.getCopyRightHolderName());//SimpleFieldAssign//sourceId:2044056_1_74001
                }

                /*D8新增专辑文件关系(公共)[10324]   */
                Assert.isNull(addAlbumFileRelationComReqDto.getResourceFileId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getAlbumId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getCreateOwnerObjectId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getCopyrightOwnerName(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-版权归属对象名称不能为空", false);
                addAlbumFileRelationComRespDto = addAlbumFileRelationCom(addAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            } else if ((queryAlbumFileRelationDetailCommonComRespDto != null && queryAlbumFileRelationDetailCommonComRespDto.getAlbumRelationId() == null && queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 1)) {
                //elseif((D8查询指定专辑与文件关系是否已存在.专辑文档关系ID 值等于空  and D8查询专辑文件关系列表（非1条关系：非默认专辑；1条关系：判断是否默认专辑）.专辑文档关系列表数据集条数 等于 1))  74040

                QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailComRespDto = null;
                QueryAlbumFileRelationDetailComReqDto queryAlbumFileRelationDetailComReqDto = new QueryAlbumFileRelationDetailComReqDto();
                queryAlbumFileRelationDetailComReqDto.setIsArchive("FALSE");//sourceId:2047450_1_74058
                queryAlbumFileRelationDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2047451_1_74058
                queryAlbumFileRelationDetailComReqDto.setIsValid("FALSE");//sourceId:2047452_1_74058
                if (circulationCollectionsRes != null) {
                    queryAlbumFileRelationDetailComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2047447_1_74058
                }
                if (reqDto != null) {
                    queryAlbumFileRelationDetailComReqDto.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047449_1_74058
                }

                /*D8查询唯一条关系ID（可用于修改入参）[10342]   */
                Assert.isNull(queryAlbumFileRelationDetailComReqDto.getResourceFileId(), "D8复制或移动文件到指定专辑-D8查询唯一条关系ID（可用于修改入参）-资源文件ID不能为空", false);
                Assert.isNull(queryAlbumFileRelationDetailComReqDto.getCreateOwnerObjectId(), "D8复制或移动文件到指定专辑-D8查询唯一条关系ID（可用于修改入参）-创建于归属主体ID不能为空", false);
                Assert.isNull(queryAlbumFileRelationDetailComReqDto.getIsArchive(), "D8复制或移动文件到指定专辑-D8查询唯一条关系ID（可用于修改入参）-是否存档不能为空", false);
                Assert.isNull(queryAlbumFileRelationDetailComReqDto.getSubjectLifeCycle(), "D8复制或移动文件到指定专辑-D8查询唯一条关系ID（可用于修改入参）-主体生命周期不能为空", false);
                Assert.isNull(queryAlbumFileRelationDetailComReqDto.getIsValid(), "D8复制或移动文件到指定专辑-D8查询唯一条关系ID（可用于修改入参）-是否作废不能为空", false);
                queryAlbumFileRelationDetailComRespDto = queryAlbumFileRelationDetailCom(queryAlbumFileRelationDetailComReqDto)/*vcase invoke 同服务,同domain*/;


                QueryAlbumDetailComRespDto queryAlbumDetailComRespDto = null;
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    QueryAlbumDetailComReqDto queryAlbumDetailComReqDto = new QueryAlbumDetailComReqDto();
                    if (queryAlbumFileRelationDetailComRespDto != null) {
                        queryAlbumDetailComReqDto.setAlbumId(queryAlbumFileRelationDetailComRespDto.getAlbumId());//SimpleFieldAssign//sourceId:2047462_1_74059
                    }

                    /*D8查询专辑详情(公共)[10327]   */
                    Assert.isNull(queryAlbumDetailComReqDto.getAlbumId(), "D8复制或移动文件到指定专辑-D8查询专辑详情(公共)-专辑ID不能为空", false);
                    queryAlbumDetailComRespDto = queryAlbumDetailCom(queryAlbumDetailComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                if ((queryAlbumDetailComRespDto.getIsDefault() != null && queryAlbumDetailComRespDto.getIsDefault().equals("FALSE"))) {
                    //if(D8查询专辑详情：是否默认专辑.是否默认专辑 否 )  74052

                    AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto_2 = null;
                    AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto_1 = new AddAlbumFileRelationComReqDto();
                    if (circulationCollectionsRes != null) {
                        addAlbumFileRelationComReqDto_1.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2044053_1_74053
                    }
                    if (reqDto != null) {
                        addAlbumFileRelationComReqDto_1.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2044054_1_74053
                        addAlbumFileRelationComReqDto_1.setCreateOwnerObjectId(reqDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2044057_1_74053
                        addAlbumFileRelationComReqDto_1.setCopyrightOwnerName(reqDto.getCopyRightHolderName());//SimpleFieldAssign//sourceId:2044056_1_74053
                    }

                    /*D8新增专辑文件关系(公共)[10324]   */
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getResourceFileId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getAlbumId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getCreateOwnerObjectId(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                    Assert.isNull(addAlbumFileRelationComReqDto_1.getCopyrightOwnerName(), "D8复制或移动文件到指定专辑-D8新增专辑文件关系(公共)-版权归属对象名称不能为空", false);
                    addAlbumFileRelationComRespDto_2 = addAlbumFileRelationCom(addAlbumFileRelationComReqDto_1)/*vcase invoke 同服务,同domain*/;


                } else if ((queryAlbumDetailComRespDto != null && queryAlbumDetailComRespDto.getIsDefault() != null && queryAlbumDetailComRespDto.getIsDefault().equals("TRUE"))) {
                    //elseif(D8查询专辑详情：是否默认专辑.是否默认专辑 等于 是)  74060

                    UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
                    if (queryAlbumFileRelationDetailComRespDto != null) {
                        UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
                        if (queryAlbumFileRelationDetailComRespDto != null) {
                            updateAlbumFileRelationComReqDto.setAlbumRelationId(queryAlbumFileRelationDetailComRespDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047369_1_74061
                        }
                        if (reqDto != null) {
                            updateAlbumFileRelationComReqDto.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2047370_1_74061
                        }

                        /*D8修改专辑文件关系(默认专辑ID修改为指定专辑ID)[10325]   */
                        Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8复制或移动文件到指定专辑-D8修改专辑文件关系(默认专辑ID修改为指定专辑ID)-专辑文档关系ID不能为空", false);
                        updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


                    }
                } else {
                    //else  74054

//异常结束 74062
                    throw new BizException("3R300100525", "对不起，专辑的是否默认专辑数据为空，请检查数据~", false);
                }
            } else if ((queryAlbumFileRelationDetailCommonComRespDto != null && queryAlbumFileRelationDetailCommonComRespDto.getAlbumRelationId() != null && queryAlbumFileRelationDetailCommonComRespDto != null && queryAlbumFileRelationDetailCommonComRespDto.getIsValid() != null && queryAlbumFileRelationDetailCommonComRespDto.getIsValid().equals("TRUE"))) {
                //elseif((D8查询指定专辑与文件关系是否已存在.专辑文档关系ID 值不等于空  and D8查询指定专辑与文件关系是否已存在.是否作废 等于 是))  74094

                UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto_1 = null;
                if (queryAlbumFileRelationDetailCommonComRespDto != null) {
                    UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto_1 = new UpdateAlbumFileRelationComReqDto();
                    if (queryAlbumFileRelationDetailCommonComRespDto != null) {
                        updateAlbumFileRelationComReqDto_1.setAlbumRelationId(queryAlbumFileRelationDetailCommonComRespDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047369_1_74095
                    }
                    if (receptionServiceRes != null) {
                        updateAlbumFileRelationComReqDto_1.setIsValid(receptionServiceRes.getIsValid());//SimpleFieldAssign//sourceId:2048746_1_74095
                    }

                    /*D8修改专辑文件关系(默认专辑ID修改为指定专辑ID)[10325]   */
                    Assert.isNull(updateAlbumFileRelationComReqDto_1.getAlbumRelationId(), "D8复制或移动文件到指定专辑-D8修改专辑文件关系(默认专辑ID修改为指定专辑ID)-专辑文档关系ID不能为空", false);
                    updateAlbumFileRelationComRespDto_1 = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto_1)/*vcase invoke 同服务,同domain*/;


                }
            }
//virtualUsage M8执行【循环结束】  74003
            //ModelCode: circulationEnd
        }

        CopyFilesToSpecAlbumRespDto retData = new CopyFilesToSpecAlbumRespDto();


        return retData;
    }

    /**
     * D8查询专辑文件关系详情(通用)（公共）[10517]
     * gen by moon at 5/26/2025, 9:36:29 PM
     */
    @Trace(operationName = "D8查询专辑文件关系详情(通用)（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAlbumFileRelationDetailCommonComRespDto queryAlbumFileRelationDetailCommonCom(QueryAlbumFileRelationDetailCommonComReqDto reqDto) {


        OmsAlbumFileRelation omsAlbumFileRelation_1 = null;
//步骤0: 8-02-02查询专辑文件关系详情 - queryAlbumFileRelationDetail
        OmsAlbumFileRelation omsAlbumFileRelation = null;
        QueryAlbumFileRelationDetailReq queryAlbumFileRelationDetailReq = new QueryAlbumFileRelationDetailReq();
        if (reqDto != null) {
            queryAlbumFileRelationDetailReq.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2044131_1
            queryAlbumFileRelationDetailReq.setAlbumId(reqDto.getAlbumId());//SimpleFieldAssign//sourceId:2044132_1
        }

        /*8-02-02查询专辑文件关系详情[10341]   */
        Assert.isNull(queryAlbumFileRelationDetailReq.getResourceFileId(), "D8查询专辑文件关系详情(通用)（公共）-8-02-02查询专辑文件关系详情-资源文件ID不能为空", false);
        omsAlbumFileRelation = mOmsAlbumFileRelationService.queryAlbumFileRelationDetail(queryAlbumFileRelationDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsAlbumFileRelation_1 = omsAlbumFileRelation;

        QueryAlbumFileRelationDetailCommonComRespDto retData = new QueryAlbumFileRelationDetailCommonComRespDto();
        if (omsAlbumFileRelation_1 != null) {
            retData.setAlbumRelationId(omsAlbumFileRelation_1.getAlbumRelationId());//SimpleFieldAssign//sourceId:2044136_1
            retData.setResourceFileId(omsAlbumFileRelation_1.getResourceFileId());//SimpleFieldAssign//sourceId:2044137_1
            retData.setResourceFileAlias(omsAlbumFileRelation_1.getResourceFileAlias());//SimpleFieldAssign//sourceId:2044138_1
            retData.setResourceFileName(omsAlbumFileRelation_1.getResourceFileName());//SimpleFieldAssign//sourceId:2044139_1
            retData.setResourceFileNumber(omsAlbumFileRelation_1.getResourceFileNumber());//SimpleFieldAssign//sourceId:2044140_1
            retData.setResourceFileRelaPath(omsAlbumFileRelation_1.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2044141_1
            retData.setResourceFileExtension(omsAlbumFileRelation_1.getResourceFileExtension());//SimpleFieldAssign//sourceId:2044142_1
            retData.setResourceCopyRightType(omsAlbumFileRelation_1.getResourceCopyRightType());//SimpleFieldAssign//sourceId:2044143_1
            retData.setResourceCopyRightHolderId(omsAlbumFileRelation_1.getResourceCopyRightHolderId());//SimpleFieldAssign//sourceId:2044144_1
            retData.setCopyRightOriginalRoleMemberId(omsAlbumFileRelation_1.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2044145_1
            retData.setCopyrightOwnerName(omsAlbumFileRelation_1.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2044146_1
            retData.setSubjectLifeCycle(omsAlbumFileRelation_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2044147_1
            retData.setCreateTime(omsAlbumFileRelation_1.getCreateTime());//SimpleFieldAssign//sourceId:2044148_1
            retData.setReleaseTime(omsAlbumFileRelation_1.getReleaseTime());//SimpleFieldAssign//sourceId:2044149_1
            retData.setOperateTime(omsAlbumFileRelation_1.getOperateTime());//SimpleFieldAssign//sourceId:2044150_1
            retData.setIsValid(omsAlbumFileRelation_1.getIsValid());//SimpleFieldAssign//sourceId:2044151_1
            retData.setCreateOwnerObjectId(omsAlbumFileRelation_1.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2044152_1
        }


        return retData;
    }

    /**
     * D8新增默认专辑(公共)[10523]
     * gen by moon at 4/10/2025, 10:22:36 AM
     */
    @Trace(operationName = "D8新增默认专辑(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddDefaultAlbumComRespDto addDefaultAlbumCom(AddDefaultAlbumComReqDto reqDto) {


        String string_1 = null;
//步骤0: 8-02-01新增默认专辑 - addDefaultAlbum
        String string = null;
        OmsAlbum omsAlbum = new OmsAlbum();
        omsAlbum.setFirstLetter(CommonFunctionHelper.firstChar(""));//FIRST_CHAR //sourceId:2045531_1
        if (reqDto != null) {
            omsAlbum.setAlbumName(reqDto.getAlbumName());//SimpleFieldAssign//sourceId:2045522_1
            omsAlbum.setAlbumDescribe(reqDto.getAlbumDescribe());//SimpleFieldAssign//sourceId:2045523_1
            omsAlbum.setAlbumThumbnail(reqDto.getAlbumThumbnail());//SimpleFieldAssign//sourceId:2045524_1
            omsAlbum.setAlbumOwner(reqDto.getAlbumOwner());//SimpleFieldAssign//sourceId:2045525_1
            omsAlbum.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2045526_1
            omsAlbum.setCopyRightOriginalRoleMemberId(reqDto.getCopyRightOriginalRoleMemberId());//SimpleFieldAssign//sourceId:2045527_1
            omsAlbum.setAlbumShareFromId(reqDto.getAlbumShareFromId());//SimpleFieldAssign//sourceId:2045528_1
            omsAlbum.setIsShare(reqDto.getIsShare());//SimpleFieldAssign//sourceId:2045529_1
            omsAlbum.setIsDefault(reqDto.getIsDefault());//SimpleFieldAssign//sourceId:2045530_1
            omsAlbum.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:2045532_1
            omsAlbum.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045533_1
        }

        /*8-02-01新增默认专辑[10522]   */
        Assert.isNull(omsAlbum.getAlbumName(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-专辑名称不能为空", false);
        Assert.isNull(omsAlbum.getAlbumOwner(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-版权归属类型不能为空", false);
        Assert.isNull(omsAlbum.getAlbumOwnerId(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-版权归属对象ID不能为空", false);
        Assert.isNull(omsAlbum.getIsShare(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-是否可分享不能为空", false);
        Assert.isNull(omsAlbum.getIsDefault(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-是否默认专辑不能为空", false);
        Assert.isNull(omsAlbum.getFirstLetter(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-名称首字母不能为空", false);
        Assert.isNull(omsAlbum.getSubjectLifeCycle(), "D8新增默认专辑(公共)-8-02-01新增默认专辑-主体生命周期不能为空", false);
        string = mOmsAlbumService.addDefaultAlbum(omsAlbum)/*vcase invoke 本地 method 方法调用;*/;


        string_1 = string;

        AddDefaultAlbumComRespDto retData = new AddDefaultAlbumComRespDto();
        if (string_1 != null) {
            retData.setAlbumId(string_1);//SimpleFieldAssign//sourceId:2045546_1
        }


        return retData;
    }

    /**
     * D8分析专辑归属对象ID(公共)[10527]
     * gen by moon at 5/11/2025, 1:22:13 PM
     */
    @Trace(operationName = "D8分析专辑归属对象ID(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalyzeAlbumOwnershipIdRespDto analyzeAlbumOwnershipId(AnalyzeAlbumOwnershipIdReqDto reqDto) {


        QueryUnstructuredDataExtractFieldDetailRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_ORG_INDUCTION_RECORD"))) {
            //if(D8分析专辑归属对象ID(公共).归属内容表类型编码 等于 就职记录表)  74029

//ModelCode: receptionService
            QueryUnstructuredDataExtractFieldDetailRespDto receptionServiceRes = null;
            QueryUnstructuredDataExtractFieldDetailReqDto receptionServiceReq = new QueryUnstructuredDataExtractFieldDetailReqDto();
            receptionServiceReq.setAlbumOwnerId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:2047138_1_74038

            /*M8约定当前就职记录ID字段[10528]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getAlbumOwnerId(), "D8分析专辑归属对象ID(公共)-M8约定当前就职记录ID字段-版权归属对象ID不能为空", false);
            receptionServiceRes = nbAlbum.queryUnstructuredDataExtractFieldDetail(receptionServiceReq);


//ModelCode: receptionService
            QueryUnstructuredDataExtractFieldDetailRespDto receptionServiceRes_2 = null;
            QueryUnstructuredDataExtractFieldDetailReqDto receptionServiceReq_1 = new QueryUnstructuredDataExtractFieldDetailReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setAlbumOwnerId(receptionServiceRes.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2047134_1_74036
            }

            /*M8接收出参字段：归属对象ID[10528]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getAlbumOwnerId(), "D8分析专辑归属对象ID(公共)-M8接收出参字段：归属对象ID-版权归属对象ID不能为空", false);
            receptionServiceRes_2 = nbAlbum.queryUnstructuredDataExtractFieldDetail(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_ORG_DEPT"))) {
            //elseif(D8分析专辑归属对象ID(公共).归属内容表类型编码 等于 部门表)  74031

//ModelCode: receptionService
            QueryUnstructuredDataExtractFieldDetailRespDto receptionServiceRes_4 = null;
            QueryUnstructuredDataExtractFieldDetailReqDto receptionServiceReq_2 = new QueryUnstructuredDataExtractFieldDetailReqDto();
            if (reqDto != null) {
                receptionServiceReq_2.setAlbumOwnerId(reqDto.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2047134_1_74037
            }

            /*M8接收出参字段：归属对象ID[10528]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getAlbumOwnerId(), "D8分析专辑归属对象ID(公共)-M8接收出参字段：归属对象ID-版权归属对象ID不能为空", false);
            receptionServiceRes_4 = nbAlbum.queryUnstructuredDataExtractFieldDetail(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        }
        AnalyzeAlbumOwnershipIdRespDto retData = new AnalyzeAlbumOwnershipIdRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setAlbumOwnerId(receptionServiceRes_3.getAlbumOwnerId());//SimpleFieldAssign//sourceId:2047141_1
        }


        return retData;
    }

    /**
     * D8移除专辑下文件(公共)[10364]
     * gen by moon at 5/26/2025, 9:36:11 PM
     */
    @Trace(operationName = "D8移除专辑下文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RemoveFileOfAlbumComRespDto removeFileOfAlbumCom(RemoveFileOfAlbumComReqDto reqDto) {


        //virtualUsage D8查询专辑文件关系详情(公共)  73471
        QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailComRespDto = null;
        QueryAlbumFileRelationDetailComReqDto queryAlbumFileRelationDetailComReqDto = new QueryAlbumFileRelationDetailComReqDto();
        if (reqDto != null) {
            queryAlbumFileRelationDetailComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2027373_1_73471
        }

        /*D8查询专辑文件关系详情(公共)[10342]   */
        Assert.isNull(queryAlbumFileRelationDetailComReqDto.getAlbumRelationId(), "D8移除专辑下文件(公共)-D8查询专辑文件关系详情(公共)-专辑文档关系ID不能为空", false);
        queryAlbumFileRelationDetailComRespDto = queryAlbumFileRelationDetailCom(queryAlbumFileRelationDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8执行生命周期判断(公共)  73472
        ImplementSubjectLifeCycleJudgeComRespDto implementSubjectLifeCycleJudgeComRespDto = null;
        if (queryAlbumFileRelationDetailComRespDto != null) {
            ImplementSubjectLifeCycleJudgeComReqDto implementSubjectLifeCycleJudgeComReqDto = new ImplementSubjectLifeCycleJudgeComReqDto();
            implementSubjectLifeCycleJudgeComReqDto.setLifecyCycleOperationType("INVALIDATE");//sourceId:2027480_1_73472
            if (queryAlbumFileRelationDetailComRespDto != null) {
                implementSubjectLifeCycleJudgeComReqDto.setSubjectLifeCycle(queryAlbumFileRelationDetailComRespDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2027481_1_73472
                implementSubjectLifeCycleJudgeComReqDto.setIsValid(queryAlbumFileRelationDetailComRespDto.getIsValid());//SimpleFieldAssign//sourceId:2027482_1_73472
            }

            /*D8执行生命周期判断(公共)[10346]   */
            Assert.isNull(implementSubjectLifeCycleJudgeComReqDto.getLifecyCycleOperationType(), "D8移除专辑下文件(公共)-D8执行生命周期判断(公共)-生命周期操作类型不能为空", false);
            implementSubjectLifeCycleJudgeComRespDto = unstructuredResourcesService.implementSubjectLifeCycleJudgeCom(implementSubjectLifeCycleJudgeComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage D8修改专辑文件关系(公共)  73473
        UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
        UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
        updateAlbumFileRelationComReqDto.setIsValid("TRUE");//sourceId:2027343_1_73473
        if (reqDto != null) {
            updateAlbumFileRelationComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2027341_1_73473
        }

        /*D8修改专辑文件关系(公共)[10325]   */
        Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8移除专辑下文件(公共)-D8修改专辑文件关系(公共)-专辑文档关系ID不能为空", false);
        Assert.isNull(updateAlbumFileRelationComReqDto.getIsValid(), "D8移除专辑下文件(公共)-D8修改专辑文件关系(公共)-是否作废不能为空", false);
        updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8查询专辑文件关系列表(公共)  73474
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2027403_1_73474
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2027402_1_73474
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileId(), "D8移除专辑下文件(公共)-D8查询专辑文件关系列表(公共)-资源文件ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8移除专辑下文件(公共)-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 0 && queryAlbumFileRelationDetailComRespDto != null && queryAlbumFileRelationDetailComRespDto.getResourceCopyRightType() != null && queryAlbumFileRelationDetailComRespDto.getResourceCopyRightType().equals("OMS_ORG_DEPT"))) {
            //if((D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0 and D8查询专辑文件关系详情(公共).冗余资源文件版权归属类型 等于 部门表))  73478

            QueryAlbumDetailComRespDto queryAlbumDetailComRespDto = null;
            if (queryAlbumFileRelationDetailComRespDto != null) {
                QueryAlbumDetailComReqDto queryAlbumDetailComReqDto = new QueryAlbumDetailComReqDto();
                queryAlbumDetailComReqDto.setIsDefault("TRUE");//sourceId:2047504_1_74063
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    queryAlbumDetailComReqDto.setAlbumOwnerId(queryAlbumFileRelationDetailComRespDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047505_1_74063
                }

                /*D8查询专辑详情(公共)[10327]   */
                Assert.isNull(queryAlbumDetailComReqDto.getIsDefault(), "D8移除专辑下文件(公共)-D8查询专辑详情(公共)-是否默认专辑不能为空", false);
                queryAlbumDetailComRespDto = queryAlbumDetailCom(queryAlbumDetailComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto = null;
            if (queryAlbumDetailComRespDto != null && queryAlbumFileRelationDetailComRespDto != null) {
                AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto = new AddAlbumFileRelationComReqDto();
                if (reqDto != null) {
                    addAlbumFileRelationComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047494_1_74064
                }
                if (queryAlbumDetailComRespDto != null) {
                    addAlbumFileRelationComReqDto.setAlbumId(queryAlbumDetailComRespDto.getAlbumId());//SimpleFieldAssign//sourceId:2047495_1_74064
                }
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    addAlbumFileRelationComReqDto.setCopyrightOwnerName(queryAlbumFileRelationDetailComRespDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2047497_1_74064
                    addAlbumFileRelationComReqDto.setCreateOwnerObjectId(queryAlbumFileRelationDetailComRespDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047498_1_74064
                }

                /*D8新增专辑文件关系(公共)[10324]   */
                Assert.isNull(addAlbumFileRelationComReqDto.getResourceFileId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getAlbumId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto.getCreateOwnerObjectId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                addAlbumFileRelationComRespDto = addAlbumFileRelationCom(addAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        } else if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 0 && queryAlbumFileRelationDetailComRespDto != null && queryAlbumFileRelationDetailComRespDto.getResourceCopyRightType() != null && queryAlbumFileRelationDetailComRespDto.getResourceCopyRightType().equals("OMS_ORG_INDUCTION_RECORD"))) {
            //elseif((D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 0 and D8查询专辑文件关系详情(公共).冗余资源文件版权归属类型 等于 就职记录表))  74068

            QueryAlbumDetailComRespDto queryAlbumDetailComRespDto_2 = null;
            if (queryAlbumFileRelationDetailComRespDto != null) {
                QueryAlbumDetailComReqDto queryAlbumDetailComReqDto_1 = new QueryAlbumDetailComReqDto();
                queryAlbumDetailComReqDto_1.setIsDefault("TRUE");//sourceId:2047504_1_74069
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    queryAlbumDetailComReqDto_1.setCopyRightOriginalRoleMemberId(queryAlbumFileRelationDetailComRespDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047506_1_74069
                }

                /*D8查询专辑详情(公共)[10327]   */
                Assert.isNull(queryAlbumDetailComReqDto_1.getIsDefault(), "D8移除专辑下文件(公共)-D8查询专辑详情(公共)-是否默认专辑不能为空", false);
                queryAlbumDetailComRespDto_2 = queryAlbumDetailCom(queryAlbumDetailComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
            AddAlbumFileRelationComRespDto addAlbumFileRelationComRespDto_2 = null;
            if (queryAlbumDetailComRespDto_2 != null && queryAlbumFileRelationDetailComRespDto != null) {
                AddAlbumFileRelationComReqDto addAlbumFileRelationComReqDto_1 = new AddAlbumFileRelationComReqDto();
                if (reqDto != null) {
                    addAlbumFileRelationComReqDto_1.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047494_1_74070
                }
                if (queryAlbumDetailComRespDto_2 != null) {
                    addAlbumFileRelationComReqDto_1.setAlbumId(queryAlbumDetailComRespDto_2.getAlbumId());//SimpleFieldAssign//sourceId:2047495_1_74070
                }
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    addAlbumFileRelationComReqDto_1.setCopyrightOwnerName(queryAlbumFileRelationDetailComRespDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2047497_1_74070
                    addAlbumFileRelationComReqDto_1.setCreateOwnerObjectId(queryAlbumFileRelationDetailComRespDto.getCreateOwnerObjectId());//SimpleFieldAssign//sourceId:2047498_1_74070
                }

                /*D8新增专辑文件关系(公共)[10324]   */
                Assert.isNull(addAlbumFileRelationComReqDto_1.getResourceFileId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-资源文件ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto_1.getAlbumId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-关联专辑ID不能为空", false);
                Assert.isNull(addAlbumFileRelationComReqDto_1.getCreateOwnerObjectId(), "D8移除专辑下文件(公共)-D8新增专辑文件关系(公共)-创建于归属主体ID不能为空", false);
                addAlbumFileRelationComRespDto_2 = addAlbumFileRelationCom(addAlbumFileRelationComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
        }
        RemoveFileOfAlbumComRespDto retData = new RemoveFileOfAlbumComRespDto();


        return retData;
    }

    /**
     * D8批量移除专辑下文件[10531]
     * gen by moon at 5/26/2025, 9:36:31 PM
     */
    @Trace(operationName = "D8批量移除专辑下文件")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateAlbumFilesRelationComRespDto updateAlbumFilesRelationCom(UpdateAlbumFilesRelationComReqDto reqDto) {


        //virtualUsage M8执行专辑文件关系【循环开始】  74045
        //ModelCode: circulationCollections
        for (AlbumFileRelationDto circulationCollectionsRes : reqDto.getAlbumFileRelationList()) {

//virtualUsage D8查询专辑文件关系详情(公共)  74046
            QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailComRespDto = null;
            QueryAlbumFileRelationDetailComReqDto queryAlbumFileRelationDetailComReqDto = new QueryAlbumFileRelationDetailComReqDto();
            if (circulationCollectionsRes != null) {
                queryAlbumFileRelationDetailComReqDto.setAlbumRelationId(circulationCollectionsRes.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047330_1_74046
            }

            /*D8查询专辑文件关系详情(公共)[10342]   */
            Assert.isNull(queryAlbumFileRelationDetailComReqDto.getAlbumRelationId(), "D8批量移除专辑下文件-D8查询专辑文件关系详情(公共)-专辑文档关系ID不能为空", false);
            queryAlbumFileRelationDetailComRespDto = queryAlbumFileRelationDetailCom(queryAlbumFileRelationDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D8移除专辑下文件(公共)  74047
            RemoveFileOfAlbumComRespDto removeFileOfAlbumComRespDto = null;
            RemoveFileOfAlbumComReqDto removeFileOfAlbumComReqDto = new RemoveFileOfAlbumComReqDto();
            if (circulationCollectionsRes != null) {
                removeFileOfAlbumComReqDto.setAlbumRelationId(circulationCollectionsRes.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047550_1_74047
                removeFileOfAlbumComReqDto.setResourceFileId(circulationCollectionsRes.getResourceFileId());//SimpleFieldAssign//sourceId:2047549_1_74047
            }

            /*D8移除专辑下文件(公共)[10364]   */
            Assert.isNull(removeFileOfAlbumComReqDto.getAlbumRelationId(), "D8批量移除专辑下文件-D8移除专辑下文件(公共)-专辑文档关系ID不能为空", false);
            Assert.isNull(removeFileOfAlbumComReqDto.getResourceFileId(), "D8批量移除专辑下文件-D8移除专辑下文件(公共)-资源文件ID不能为空", false);
            removeFileOfAlbumComRespDto = removeFileOfAlbumCom(removeFileOfAlbumComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage M8执行【循环结束】  74051
            //ModelCode: circulationEnd
        }


        UpdateAlbumFilesRelationComRespDto retData = new UpdateAlbumFilesRelationComRespDto();


        return retData;
    }

    /**
     * D8批量存档专辑下文件[10532]
     * gen by moon at 5/24/2025, 8:18:17 PM
     */
    @Trace(operationName = "D8批量存档专辑下文件")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchArchiveAlbumFileRelationRespDto batchArchiveAlbumFileRelation(BatchArchiveAlbumFileRelationReqDto reqDto) {


        //步骤0: M8执行非结构化数据接收入参字段入参 - implementUnstructuredDataReceiveField
        //ModelCode: receptionService
        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
        ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
        if (reqDto != null) {
            //simpleList-to-objLists
            for (String item : reqDto.getAlbumFileRelationList()) {
                AlbumFileRelationDto oneItem = new AlbumFileRelationDto();
                if (reqDto != null) {
                    oneItem.setAlbumRelationId(item);//SimpleFieldAssign//sourceId:434697_2
                }

                receptionServiceReq.getAlbumFileRelationList().add(oneItem);
            }//sourceId:2047324_1
        }

        /*M8执行非结构化数据接收入参字段入参[10347]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


//步骤1: M8执行专辑文件关系【循环开始】 - implementAlbumFileRelation
        //ModelCode: circulationCollections
        for (String circulationCollectionsRes : reqDto.getAlbumFileRelationList()) {


//步骤2: D8修改专辑文件关系(公共) - updateAlbumFileRelationCom
            UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
            UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
            updateAlbumFileRelationComReqDto.setIsArchive("TRUE");//sourceId:2047326_1
            updateAlbumFileRelationComReqDto.setSubjectLifeCycle("ARCHIVING");//sourceId:2047322_1
            if (circulationCollectionsRes != null) {
                updateAlbumFileRelationComReqDto.setAlbumRelationId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:2047318_1
            }

            /*D8修改专辑文件关系(公共)[10325]   */
            Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8批量存档专辑下文件-D8修改专辑文件关系(公共)-专辑文档关系ID不能为空", false);
            updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤3: M8执行【循环结束】 - implementLoopStopResource
            //ModelCode: circulationEnd
        }


        BatchArchiveAlbumFileRelationRespDto retData = new BatchArchiveAlbumFileRelationRespDto();


        return retData;
    }

    /**
     * D8查询专辑下文件详情(公共)[10534]
     * gen by moon at 5/28/2025, 6:05:37 PM
     */
    @Trace(operationName = "D8查询专辑下文件详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryFileOfAlbumDetailComRespDto queryFileOfAlbumDetailCom(QueryFileOfAlbumDetailComReqDto reqDto) {


        ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getAlbumRelationId() != null)) {
            //if(D8查询专辑下文件详情(公共).专辑文档关系ID 值不等于空 )  74071

            QueryAlbumFileRelationDetailComRespDto queryAlbumFileRelationDetailComRespDto = null;
            QueryAlbumFileRelationDetailComReqDto queryAlbumFileRelationDetailComReqDto = new QueryAlbumFileRelationDetailComReqDto();
            if (reqDto != null) {
                queryAlbumFileRelationDetailComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047695_1_74072
            }

            /*D8查询专辑文件关系详情(公共)[10342]   */
            Assert.isNull(queryAlbumFileRelationDetailComReqDto.getAlbumRelationId(), "D8查询专辑下文件详情(公共)-D8查询专辑文件关系详情(公共)-专辑文档关系ID不能为空", false);
            queryAlbumFileRelationDetailComRespDto = queryAlbumFileRelationDetailCom(queryAlbumFileRelationDetailComReqDto)/*vcase invoke 同服务,同domain*/;


            QueryResourceFileDetailComRespDto queryResourceFileDetailComRespDto = null;
            QueryResourceFileDetailComReqDto queryResourceFileDetailComReqDto = new QueryResourceFileDetailComReqDto();
            if (reqDto != null) {
                queryResourceFileDetailComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047701_1_74073
            }

            /*D8查询资源文件详情(公共)[10321]   */
            Assert.isNull(queryResourceFileDetailComReqDto.getResourceFileId(), "D8查询专辑下文件详情(公共)-D8查询资源文件详情(公共)-资源文件ID不能为空", false);
            queryResourceFileDetailComRespDto = resourceFileService.queryResourceFileDetailCom(queryResourceFileDetailComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes = null;
            if (queryResourceFileDetailComRespDto != null && queryAlbumFileRelationDetailComRespDto != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (queryResourceFileDetailComRespDto != null) {
                    receptionServiceReq.setResourceFileId(queryResourceFileDetailComRespDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047676_1_74076
                    receptionServiceReq.setResourceFileName(queryResourceFileDetailComRespDto.getResourceFileName());//SimpleFieldAssign//sourceId:2047685_1_74076
                    receptionServiceReq.setResourceFileExtension(queryResourceFileDetailComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2047903_1_74076
                    receptionServiceReq.setResourceFileSummary(queryResourceFileDetailComRespDto.getResourceFileSummary());//SimpleFieldAssign//sourceId:2047686_1_74076
                    receptionServiceReq.setIsEvi(queryResourceFileDetailComRespDto.getIsEvi());//SimpleFieldAssign//sourceId:2047688_1_74076
                    receptionServiceReq.setEviRecordId(queryResourceFileDetailComRespDto.getEviRecordId());//SimpleFieldAssign//sourceId:2047687_1_74076
                    receptionServiceReq.setHashCode(queryResourceFileDetailComRespDto.getHashCode());//SimpleFieldAssign//sourceId:2047684_1_74076
                    receptionServiceReq.setResourceFileCataObjectId(queryResourceFileDetailComRespDto.getResourceFileCataObjectId());//SimpleFieldAssign//sourceId:2047693_1_74076
                }
                if (queryAlbumFileRelationDetailComRespDto != null) {
                    receptionServiceReq.setResourceFileAlias(queryAlbumFileRelationDetailComRespDto.getResourceFileAlias());//SimpleFieldAssign//sourceId:2047694_1_74076
                    receptionServiceReq.setCopyRightHolderName(queryAlbumFileRelationDetailComRespDto.getCopyrightOwnerName());//SimpleFieldAssign//sourceId:2047667_1_74076
                    receptionServiceReq.setCreateTime(queryAlbumFileRelationDetailComRespDto.getCreateTime());//SimpleFieldAssign//sourceId:2047689_1_74076
                    receptionServiceReq.setOperateTime(queryAlbumFileRelationDetailComRespDto.getOperateTime());//SimpleFieldAssign//sourceId:2047690_1_74076
                }

                /*M8接收出参字段[10347]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getResourceFileId(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件ID不能为空", false);
                Assert.isNull(receptionServiceReq.getResourceFileName(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件名称不能为空", false);
                Assert.isNull(receptionServiceReq.getResourceFileExtension(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件后缀不能为空", false);
                Assert.isNull(receptionServiceReq.getIsEvi(), "D8查询专辑下文件详情(公共)-M8接收出参字段-是否有存证不能为空", false);
                Assert.isNull(receptionServiceReq.getCreateTime(), "D8查询专辑下文件详情(公共)-M8接收出参字段-创建时间不能为空", false);
                Assert.isNull(receptionServiceReq.getOperateTime(), "D8查询专辑下文件详情(公共)-M8接收出参字段-操作时间不能为空", false);
                receptionServiceRes = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getAlbumRelationId() == null)) {
            //elseif(D8查询专辑下文件详情(公共).专辑文档关系ID 值等于空 )  74074

            QueryResourceFileDetailComRespDto queryResourceFileDetailComRespDto_2 = null;
            QueryResourceFileDetailComReqDto queryResourceFileDetailComReqDto_1 = new QueryResourceFileDetailComReqDto();
            if (reqDto != null) {
                queryResourceFileDetailComReqDto_1.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047701_1_74075
            }

            /*D8查询资源文件详情(公共)[10321]   */
            Assert.isNull(queryResourceFileDetailComReqDto_1.getResourceFileId(), "D8查询专辑下文件详情(公共)-D8查询资源文件详情(公共)-资源文件ID不能为空", false);
            queryResourceFileDetailComRespDto_2 = resourceFileService.queryResourceFileDetailCom(queryResourceFileDetailComReqDto_1)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            ImplementUnstructuredDataReceiveFieldRespDto receptionServiceRes_2 = null;
            if (queryResourceFileDetailComRespDto_2 != null) {
                ImplementUnstructuredDataReceiveFieldReqDto receptionServiceReq_1 = new ImplementUnstructuredDataReceiveFieldReqDto();
                if (queryResourceFileDetailComRespDto_2 != null) {
                    receptionServiceReq_1.setResourceFileId(queryResourceFileDetailComRespDto_2.getResourceFileId());//SimpleFieldAssign//sourceId:2047676_1_74077
                    receptionServiceReq_1.setResourceFileName(queryResourceFileDetailComRespDto_2.getResourceFileName());//SimpleFieldAssign//sourceId:2047685_1_74077
                    receptionServiceReq_1.setResourceFileExtension(queryResourceFileDetailComRespDto_2.getResourceFileExtension());//SimpleFieldAssign//sourceId:2047903_1_74077
                    receptionServiceReq_1.setResourceFileSummary(queryResourceFileDetailComRespDto_2.getResourceFileSummary());//SimpleFieldAssign//sourceId:2047686_1_74077
                    receptionServiceReq_1.setIsEvi(queryResourceFileDetailComRespDto_2.getIsEvi());//SimpleFieldAssign//sourceId:2047688_1_74077
                    receptionServiceReq_1.setEviRecordId(queryResourceFileDetailComRespDto_2.getEviRecordId());//SimpleFieldAssign//sourceId:2047687_1_74077
                    receptionServiceReq_1.setHashCode(queryResourceFileDetailComRespDto_2.getHashCode());//SimpleFieldAssign//sourceId:2047684_1_74077
                    receptionServiceReq_1.setResourceFileCataObjectId(queryResourceFileDetailComRespDto_2.getResourceFileCataObjectId());//SimpleFieldAssign//sourceId:2047693_1_74077
                    receptionServiceReq_1.setCreateTime(queryResourceFileDetailComRespDto_2.getCreateTime());//SimpleFieldAssign//sourceId:2047689_1_74077
                    receptionServiceReq_1.setOperateTime(queryResourceFileDetailComRespDto_2.getOperateTime());//SimpleFieldAssign//sourceId:2047690_1_74077
                }

                /*M8接收出参字段[10347]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getResourceFileId(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件ID不能为空", false);
                Assert.isNull(receptionServiceReq_1.getResourceFileName(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件名称不能为空", false);
                Assert.isNull(receptionServiceReq_1.getResourceFileExtension(), "D8查询专辑下文件详情(公共)-M8接收出参字段-资源文件后缀不能为空", false);
                Assert.isNull(receptionServiceReq_1.getIsEvi(), "D8查询专辑下文件详情(公共)-M8接收出参字段-是否有存证不能为空", false);
                Assert.isNull(receptionServiceReq_1.getCreateTime(), "D8查询专辑下文件详情(公共)-M8接收出参字段-创建时间不能为空", false);
                Assert.isNull(receptionServiceReq_1.getOperateTime(), "D8查询专辑下文件详情(公共)-M8接收出参字段-操作时间不能为空", false);
                receptionServiceRes_2 = nbAlbum.implementUnstructuredDataReceiveField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        QueryFileOfAlbumDetailComRespDto retData = new QueryFileOfAlbumDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setResourceFileId(receptionServiceRes_1.getResourceFileId());//SimpleFieldAssign//sourceId:2047727_1
            retData.setResourceFileName(receptionServiceRes_1.getResourceFileName());//SimpleFieldAssign//sourceId:2047728_1
            retData.setResourceFileAlias(receptionServiceRes_1.getResourceFileAlias());//SimpleFieldAssign//sourceId:2047729_1
            retData.setResourceFileExtension(receptionServiceRes_1.getResourceFileExtension());//SimpleFieldAssign//sourceId:2047906_1
            retData.setResourceFileSummary(receptionServiceRes_1.getResourceFileSummary());//SimpleFieldAssign//sourceId:2047730_1
            retData.setIsEvi(receptionServiceRes_1.getIsEvi());//SimpleFieldAssign//sourceId:2047731_1
            retData.setCopyRightHolderName(receptionServiceRes_1.getCopyRightHolderName());//SimpleFieldAssign//sourceId:2047732_1
            retData.setEviRecordId(receptionServiceRes_1.getEviRecordId());//SimpleFieldAssign//sourceId:2047733_1
            retData.setHashCode(receptionServiceRes_1.getHashCode());//SimpleFieldAssign//sourceId:2047734_1
            retData.setResourceFileCataObjectId(receptionServiceRes_1.getResourceFileCataObjectId());//SimpleFieldAssign//sourceId:2047735_1
            retData.setCreateTime(receptionServiceRes_1.getCreateTime());//SimpleFieldAssign//sourceId:2047736_1
            retData.setOperateTime(receptionServiceRes_1.getOperateTime());//SimpleFieldAssign//sourceId:2047737_1
        }


        return retData;
    }

    /**
     * D8执行丢回收站(公共)[10535]
     * gen by moon at 5/27/2025, 1:21:14 PM
     */
    @Trace(operationName = "D8执行丢回收站(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRecycleComRespDto implementRecycleCom(ImplementRecycleComReqDto reqDto) {


        //virtualUsage D8查询专辑文件关系列表(公共)  74079
        QueryAlbumFileRelationListComRespDto queryAlbumFileRelationListComRespDto = null;
        QueryAlbumFileRelationListComReqDto queryAlbumFileRelationListComReqDto = new QueryAlbumFileRelationListComReqDto();
        queryAlbumFileRelationListComReqDto.setIsValid("FALSE");//sourceId:2047840_1_74079
        if (reqDto != null) {
            queryAlbumFileRelationListComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047841_1_74079
        }

        /*D8查询专辑文件关系列表(公共)[10330]   */
        Assert.isNull(queryAlbumFileRelationListComReqDto.getResourceFileId(), "D8执行丢回收站(公共)-D8查询专辑文件关系列表(公共)-资源文件ID不能为空", false);
        Assert.isNull(queryAlbumFileRelationListComReqDto.getIsValid(), "D8执行丢回收站(公共)-D8查询专辑文件关系列表(公共)-是否作废不能为空", false);
        queryAlbumFileRelationListComRespDto = queryAlbumFileRelationListCom(queryAlbumFileRelationListComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() > 1)) {
            //if(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 大于 1)  74080

//异常结束 74081
            throw new BizException("3R300100526", "对不起，这个文件已分享给他人使用中，请确认并处理后再删除~", false);
        } else if ((queryAlbumFileRelationListComRespDto != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList() != null && queryAlbumFileRelationListComRespDto.getAlbumFileRelationList().size() == 1)) {
            //elseif(D8查询专辑文件关系列表(公共).专辑文档关系列表数据集条数 等于 1)  74082

            UpdateAlbumFileRelationComRespDto updateAlbumFileRelationComRespDto = null;
            UpdateAlbumFileRelationComReqDto updateAlbumFileRelationComReqDto = new UpdateAlbumFileRelationComReqDto();
            updateAlbumFileRelationComReqDto.setIsValid("TRUE");//sourceId:2047823_1_74083
            if (reqDto != null) {
                updateAlbumFileRelationComReqDto.setAlbumRelationId(reqDto.getAlbumRelationId());//SimpleFieldAssign//sourceId:2047821_1_74083
            }

            /*D8修改专辑文件关系(公共)[10325]   */
            Assert.isNull(updateAlbumFileRelationComReqDto.getAlbumRelationId(), "D8执行丢回收站(公共)-D8修改专辑文件关系(公共)-专辑文档关系ID不能为空", false);
            Assert.isNull(updateAlbumFileRelationComReqDto.getIsValid(), "D8执行丢回收站(公共)-D8修改专辑文件关系(公共)-是否作废不能为空", false);
            updateAlbumFileRelationComRespDto = updateAlbumFileRelationCom(updateAlbumFileRelationComReqDto)/*vcase invoke 同服务,同domain*/;


            UpdateResourceFileComRespDto updateResourceFileComRespDto = null;
            UpdateResourceFileComReqDto updateResourceFileComReqDto = new UpdateResourceFileComReqDto();
            updateResourceFileComReqDto.setIsValid("TRUE");//sourceId:2047830_1_74084
            if (reqDto != null) {
                updateResourceFileComReqDto.setResourceFileId(reqDto.getResourceFileId());//SimpleFieldAssign//sourceId:2047831_1_74084
            }

            /*D8修改资源文件(公共)[10317]   */
            Assert.isNull(updateResourceFileComReqDto.getResourceFileId(), "D8执行丢回收站(公共)-D8修改资源文件(公共)-资源文件ID不能为空", false);
            Assert.isNull(updateResourceFileComReqDto.getIsValid(), "D8执行丢回收站(公共)-D8修改资源文件(公共)-是否作废不能为空", false);
            updateResourceFileComRespDto = resourceFileService.updateResourceFileCom(updateResourceFileComReqDto)/*vcase invoke isSameApp*/;


        }
        ImplementRecycleComRespDto retData = new ImplementRecycleComRespDto();


        return retData;
    }

    /**
     * D8批量删专辑文件关系(公共)[10538]
     * gen by moon at 5/27/2025, 1:42:11 PM
     */
    @Trace(operationName = "D8批量删专辑文件关系(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchDeleteAlbumFileRelationComRespDto batchDeleteAlbumFileRelationCom(BatchDeleteAlbumFileRelationComReqDto reqDto) {


        //步骤0: 8-02-02批量删专辑文件关系 - batchDeleteAlbumFileRelation
        boolean bOOLEAN;
        List<String> listString = new ArrayList<>();
        if (reqDto != null) {
            listString = reqDto.getAlbumFileRelationList();
            ;//list-field-assign//sourceId:2047864_1
        }

        /*8-02-02批量删专辑文件关系[10537]   */

        bOOLEAN = mOmsAlbumFileRelationService.batchDeleteAlbumFileRelation(listString)/*vcase invoke 本地 method 方法调用;*/;


        BatchDeleteAlbumFileRelationComRespDto retData = new BatchDeleteAlbumFileRelationComRespDto();


        return retData;
    }
    //
}
